package main

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

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func nextInt(sc *bufio.Scanner) int {
	sc.Scan()
	t, _ := strconv.Atoi(sc.Text())
	return t
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	t := nextInt(sc)
	ans := make([]string, 0)
	for i := 0; i < t; i++ {
		a := nextInt(sc)
		b := nextInt(sc)
		c := nextInt(sc)
		n := nextInt(sc)
		m := max(a, max(b, c))
		s := 3*m - (a + b + c) // short
		if n >= s && (n-s)%3 == 0 {
			ans = append(ans, "YES")
		} else {
			ans = append(ans, "NO")
		}
	}
	wtr := bufio.NewWriter(os.Stdout)
	for i := 0; i < len(ans); i++ {
		fmt.Fprintln(wtr, ans[i])
	}
	wtr.Flush()
}

package main

import (
	"bufio"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	scanner.Split(bufio.ScanWords)
	scanner.Scan()
	t := toInt(scanner.Bytes())
	for t > 0 {
		a := getNum(scanner)
		b := getNum(scanner)
		c := getNum(scanner)
		n := getNum(scanner)
		max := max(a, b, c)
		diff := (max * 3) - (a + b + c)

		if n - diff >= 0 && (n - diff) % 3 == 0 {
			writer.WriteString("YES\n")
		}else {
			writer.WriteString("NO\n")
		}
		t--
	}
}

func max(nums ...int) int {
	max := nums[0]
	for _, num := range nums {
		if num > max {
			max = num
		}
	}
	return max
}

func getNum(scanner *bufio.Scanner) int {
	scanner.Scan()
	return toInt(scanner.Bytes())
}

func toInt(buf []byte) int {
	v := 0
	for _, b := range buf {
		v = v * 10 + int(b - '0')
	}
	return v
}

package main

import "fmt"

func max(a, b, c int) int {
	if a >= b && a >= c {
		return a
	}
	if b >= a && b >= c {
		return b
	}
	return c
}

func main() {
	var t int
	fmt.Scan(&t)
	for ; t > 0; t-- {
		var a, b, c, n int
		fmt.Scan(&a, &b, &c, &n)
		n -= 3*max(a, b, c) - a - b - c
		if n >= 0 && n%3 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"strings"
	"sync"
)

func main() {

	t := ScanInt()
	for ; t > 0; t-- {
		curr := ScanInt64Slice(3)
		coins := ScanInt64()
		max := Mx(curr)
		for _, v := range curr {
			coins -= max - v
		}
		if coins < 0 || coins%3 != 0 {
			fmt.Println("NO")
		} else {
			fmt.Println("YES")
		}
	}
}

/*********************** I/O ***********************/

var O chan string
var in *bufio.Scanner
var oWg *sync.WaitGroup
var P func(a ...interface{}) (n int, err error)

func init() {
	P = fmt.Println

	in = bufio.NewScanner(os.Stdin)
	in.Buffer(make([]byte, 1024), int(1e+9))
	in.Split(bufio.ScanWords)

	O = make(chan string, 16)
	oWg = &sync.WaitGroup{}
	oWg.Add(1)

	writer := bufio.NewWriter(os.Stdout)
	go func() {
		defer oWg.Done()
		defer writer.Flush()

		for line := range O {
			writer.WriteString(line + "\n")
		}
	}()
}

func ScanWord() string { in.Scan(); return in.Text() }
func ScanInt() int     { i, _ := strconv.Atoi(ScanWord()); return i }
func ScanInt64() int64 { i, _ := strconv.ParseInt(ScanWord(), 10, 64); return i }
func ScanStringSlice(n int) []string {
	s := make([]string, n)
	for i := 0; i < n; i++ {
		s[i] = ScanWord()
	}
	return s
}
func ScanIntSlice(n int) []int {
	arr := make([]int, n)
	for i := 0; i < n; i++ {
		arr[i] = ScanInt()
	}
	return arr
}
func ScanInt64Slice(n int) []int64 {
	arr := make([]int64, n)
	for i := 0; i < n; i++ {
		arr[i] = ScanInt64()
	}
	return arr
}

/*********************** Utils ***********************/

func S(v interface{}) string { return fmt.Sprintf("%v", v) }
func SArr(a []int) string {
	sb := strings.Builder{}
	sb.Grow(len(a) * 9)
	for i := range a {
		sb.WriteString(strconv.Itoa(a[i]) + " ")
	}
	return sb.String()
}
func SArr64(a []int64) string {
	sb := strings.Builder{}
	sb.Grow(len(a) * 9)
	for i := range a {
		sb.WriteString(strconv.FormatInt(a[i], 10) + " ")
	}
	return sb.String()
}
func MnMx(args []int64) (int64, int64) {
	minVal, maxVal := int64(math.MaxInt64), int64(math.MinInt64)
	for _, v := range args {
		if v < minVal {
			minVal = v
		}
		if v > maxVal {
			maxVal = v
		}
	}
	return minVal, maxVal
}
func Mn(args []int64) int64 { mn, _ := MnMx(args); return mn }
func Mx(args []int64) int64 { _, mx := MnMx(args); return mx }
func LCM(a, b int64) int64  { return a / GCD(a, b) * b }
func GCD(a, b int64) int64 {
	if a == 0 {
		return b
	}
	return GCD(b%a, a)
}
func sortInt64Slice(a []int64) { sort.Slice(a, func(i, j int) bool { return a[i] < a[j] }) }
func abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

package main

import (
	"fmt"
)

func CollectingCoins(a, b, c, n int) string {
	sum := a+b+c+n
	if sum%3 == 0 {
		max := a
		if b > max {
			max = b
		}
		if c > max {
			max = c
		}
		if sum/3 >= max {
			return "YES"
		}
	}
	return "NO"
}

func main() {
	var t int
	fmt.Scanf("%d\n", &t)
	for i := 0; i < t; i++ {
		var a, b, c, n int
		fmt.Scanf("%d %d %d %d \n", &a, &b, &c, &n)
		fmt.Println(CollectingCoins(a, b, c, n))
	}
}

// https://codeforces.com/problemset/problem/1294/A

package main

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

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

	var t int
	fmt.Fscanf(in, "%d\n", &t)
	for i := 0; i < t; i++ {
		var a, b, c, p int
		var arr []int
		fmt.Fscanf(in, "%d%d%d%d\n", &a, &b, &c, &p)
		arr = append(arr, a)
		arr = append(arr, b)
		arr = append(arr, c)
		sort.Ints(arr)
		if a == b && b == c {
			if p%3 == 0 {
				fmt.Fprintln(out, "YES")
			} else {
				fmt.Fprintln(out, "NO")
			}
		} else {
			x := arr[2] - arr[0]
			y := arr[2] - arr[1]
			if x+y > p {
				fmt.Fprintln(out, "NO")
			} else if x+y == p {
				fmt.Fprintln(out, "YES")
			} else {
				p -= x + y
				if p%3 == 0 {
					fmt.Fprintln(out, "YES")
				} else {
					fmt.Fprintln(out, "NO")
				}
			}
		}
	}

}

package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }

func main () {
	solution1294A()
}

func max(a,b int) int{
	if a>b {
		return a
	}
	return b
}
func solution1294A() {
	defer writer.Flush()

	var t,a,b,c,n int
	scanf("%d\n", &t)
	for  ;t>0; t--{
		scanf("%d %d %d %d\n", &a,&b,&c,&n)
		maxnum := max(a, max(b,c))
		temp := n - (3*maxnum - a - b - c)
		if (temp >= 0 && temp % 3 == 0) {
			printf("YES\n")
		} else {
			printf("NO\n")
		}
	}
}

package main

import "fmt"

func main(){

	var t , a , b , c , n , sum int64

	fmt.Scan(&t)

	for T := 0 ; T < int(t) ; T ++ {
		fmt.Scan(&a,&b,&c,&n)
		sum = a + b + c + n
		if sum % 3 == 0 {
			sum /= 3
			if sum >= a && sum >= b && sum >= c {
				fmt.Println("YES")
			}else {
				fmt.Println("NO")
			}
		} else {
			fmt.Println("NO")
		}
	}

}

package main

import (
	"fmt"
)

func main() {

	var t, a, i, b, c, n int

	fmt.Scan(&t)

	for i = 0; i < t; i++ {

		fmt.Scan(&a, &b, &c, &n)

		ans := (a + b + c + n)

		if ans%3 != 0 {
			fmt.Printf("NO\n")
		} else {
			k := ans / 3
			if k < a || k < b || k < c {
				fmt.Printf("NO\n")
			} else {
				fmt.Printf("YES\n")
			}
		}
	}
}

package main

import(

	"fmt"
)

func main(){

	var q int

	fmt.Scan(&q)

	for i := 0; i<q; i++ {

		var a, b, c int64
		var n int64
		var sum int64 = 0

		fmt.Scan(&a)
		fmt.Scan(&b)
		fmt.Scan(&c)
		fmt.Scan(&n)

		sum = a + b + c + n

		if sum % 3 > 0 {
			fmt.Println("NO")
			continue
		}

		sum /= 3

		if sum >= a && sum >= b && sum >= c {
			fmt.Println("YES")

		} else{
			fmt.Println("NO")

		}

	}

}

package main

import "fmt"

func check(a,b,c,n int) bool{
	n+=a+b+c
	if n%3!=0 {
		return false
	}
	if a>n/3 || b>n/3 ||c>n/3{
		return false
	}
	return true
}

func work(){
	var a,b,c,n int
	fmt.Scanf("%d %d %d %d\n",&a,&b,&c,&n);
	if check(a,b,c,n){
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func main(){
	var t int
	fmt.Scanf("%d\n",&t)
	for ;t>0;t--{
		work()
	}
}

package main

import "fmt"

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	var t int
	fmt.Scan(&t)
	for i := 0; i < t; i++ {
		var a, b, c, n int
		fmt.Scan(&a, &b, &c, &n)
		m := max(a, max(b, c))
		s := 3*m - (a + b + c) // short
		if n >= s && (n-s)%3 == 0 {
			fmt.Println("Yes")
		} else {
			fmt.Println("No")
		}
	}
}

package main

import "fmt"

func main() {
	var t int
	fmt.Scanf("%d\n", &t)
	for i := 0; i < t; i++ {
		var a, b, c, n int
		fmt.Scanf("%d %d %d %d\n", &a, &b, &c, &n)

		tong := a + b + c + n
		if tong%3 == 0 && tong/3 >= a && tong/3 >= b && tong/3 >= c {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import (
	"fmt"
)
func check(sum int,a int,b int,c int) bool{
	if sum%3!=0{
		return false
	}
	sum/=3
	if sum<a || sum <b || sum<c{
		return false
	}
	return true
}
func main(){
	var t int
	fmt.Scan(&t)
	for ;t>0;t--{
		var a,b,c,n int
		fmt.Scan(&a,&b,&c,&n)
		sum := a+b+c+n
		if check(sum,a,b,c) == true{
			fmt.Println("YES")
		}else{
			fmt.Println("NO")
		}
	}
}

package main

import (
	"fmt"
	"io"
	"os"
)

func run(r io.Reader, w io.Writer) {
	var n int

	fmt.Scan(&n)

	for i := 0; i < n; i++ {
		var a, b, c int
		var n int
		var sum int = 0

		fmt.Scan(&a)
		fmt.Scan(&b)
		fmt.Scan(&c)
		fmt.Scan(&n)

		sum = a + b + c + n

		if sum % 3 > 0 {
			fmt.Println("NO")
			continue
		}

		sum /= 3

		if sum >= a && sum >= b && sum >= c {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

func main() {
	run(os.Stdin, os.Stdout)
}

package main

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

func max(a, b, c int64) int64 {
	if a >= b && a >= c {
		return a
	}
	if b >= c {
		return b
	}
	return c
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	var t int
	var a, b, c, n int64
	fmt.Fscanln(reader, &t)
	for ; t > 0; t-- {
		fmt.Fscanln(reader, &a, &b, &c, &n)
		diff := max(a, b, c)*3 - a - b - c - n
		if diff > 0 || (diff < 0 && (-1*diff)%3 != 0) {
			fmt.Fprintln(writer, "NO")
			continue
		}
		fmt.Fprintln(writer, "YES")
	}
}

package main

import "fmt"

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func main() {
	var T int
	fmt.Scan(&T)
	for t := 0; t < T; t++ {
		var a, b, c, n int
		fmt.Scan(&a, &b, &c, &n)
		tmp := max(a, max(b, c))
		n -= tmp - a
		a = tmp
		n -= tmp - b
		b = tmp
		n -= tmp - c
		c = tmp
		if n >= 0 && n%3 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"sync"
)

const (
	MX_INT int64 = math.MaxInt64
	MN_INT int64 = math.MinInt64
)

func main() {
	for t := ScanInt64(); t > 0; t-- {
		a, b, c, n := ScanInt64(), ScanInt64(), ScanInt64(), ScanInt64()
		initCoin := []int64{a, b, c}
		sort.Slice(initCoin, func(i, j int) bool { return initCoin[i] < initCoin[j] })

		adiff := initCoin[2] - initCoin[0]
		n -= adiff

		bdiff := initCoin[2] - initCoin[1]
		n -= bdiff

		if n < 0 || n%3 != 0 {
			Pl("NO")
		} else {
			Pl("YES")
		}
	}
	close(O)
	oWg.Wait()
}

/*********************** I/O ***********************/

var O chan string
var in *bufio.Scanner
var oWg *sync.WaitGroup
var Pl func(a ...interface{}) (n int, err error)

func init() {
	Pl = fmt.Println

	in = bufio.NewScanner(os.Stdin)
	in.Buffer(make([]byte, 1024), int(1e+8))
	in.Split(bufio.ScanWords)

	O = make(chan string, 16)
	oWg = &sync.WaitGroup{}
	oWg.Add(1)

	writer := bufio.NewWriterSize(os.Stdout, int(2e+5))
	go func(writer *bufio.Writer) {
		defer oWg.Done()
		defer writer.Flush()

		for line := range O {
			writer.WriteString(line + "\n")
		}
	}(writer)
}

func ScanWord() string {
	in.Scan()
	return in.Text()
}

func ScanStringSlice(n int64) []string {
	length := int(n)
	s := make([]string, n)
	for i := 0; i < length; i++ {
		s[i] = ScanWord()
	}
	return s
}

func ScanInt64() int64 {
	intStr := ScanWord()
	i, err := strconv.ParseInt(intStr, 10, 64)
	if err != nil {
		panic(err)
	}
	return i
}

func ScanInt() int {
	intStr := ScanWord()
	i, err := strconv.Atoi(intStr)
	if err != nil {
		panic(err)
	}
	return i
}

func ScanInt64Slice(n int64) []int64 {
	length := int(n)
	arr := make([]int64, n)
	for i := 0; i < length; i++ {
		arr[i] = ScanInt64()
	}
	return arr
}

/*********************** Utils ***********************/

func Mx(args ...int64) int64 {
	maxVal := MN_INT
	for _, v := range args {
		if v > maxVal {
			maxVal = v
		}
	}
	return maxVal
}

func Mn(args ...int64) int64 {
	minVal := MX_INT
	for _, v := range args {
		if v < minVal {
			minVal = v
		}
	}
	return minVal
}

func LCM(a, b int64) int64 {
	return a / GCD(a, b) * b
}

func GCD(a, b int64) int64 {
	if (a == 0) {
		return b
	}
	return GCD(b%a, a)
}

func S(v interface{}) string {
	return fmt.Sprintf("%v", v)
}

package main

import "fmt"

func main() {
	var t, a, b, c, n int
	fmt.Scan(&t)
	for i := 0; i < t; i++ {
		fmt.Scan(&a, &b, &c, &n)
		var total = a + b + c + n
		if total%3 != 0 || total/3 < a || total/3 < b || total/3 < c {
			fmt.Println("NO")
		} else {
			fmt.Println("YES")
		}
	}
}

package main

import (
	"fmt"
)

func abs(a int) int{
	if a < 0{
		return -a
	} else{
		return a
	}
}

func min(a, b int) int{
	if a < b{
		return a
	} else{
		return b
	}
}

func main(){
	var t int
	fmt.Scanln(&t)
	var a, b, c, n, ans, _max int
	for i := 0;i < t;i++  {
		_max = -1
		fmt.Scanln(&a, &b, &c, &n)
		if a > b {
			_max = a
		} else {
			_max = b
		}
		if _max < c{
			_max = c
		}
		ans = (a + b + c +n)/3
		if (a + b + c+n)%3 ==0 && ans >=_max{
			fmt.Println("YES")
		} else{
			fmt.Println("NO")
		}
	}
}

package main

import (
	"fmt"
)

func main() {
	var t int64
	fmt.Scan(&t)
	for i := int64(0); i < t; i++ {
		var a, b, c, n int64
		fmt.Scan(&a,&b,&c,&n)
		result := a+b+c+n
		if result%3 == 0 && result/3 >= a && result/3 >= b && result/3 >= c{
			fmt.Println("YES")
		}else{
			fmt.Println("NO")
		}
	}
}

package main
import (
	"fmt"
	"bufio"
	"os"
	"strings"
)
func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var t int
	fmt.Fscan(in, &t)
	ans := make([]string, t)
	for i := 0; i < t; i++ {
		var a, b, c, n int
		fmt.Fscan(in, &a, &b, &c, &n)
		m := a
		if m < b {
			m = b
		}
		if m < c {
			m = c
		}
		s := 3 * m - a - b - c

		if n >= s && (n - s)%3 == 0 {
			ans[i] = "YES"
		} else {
			ans[i] = "NO"
		}

	}
	fmt.Fprintln(out, strings.Join(ans, "\n"))

}

package main

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

func main() {
	var t, a, b, c, n int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &t)
	for i := 0; i < t; i++ {
		fmt.Fscan(in, &a, &b, &c, &n)
		m := max(a, b)
		m = max(m, c)
		sum := (m - a) + (m - b) + (m - c)

		if n >= sum && (n-sum)%3 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scanf("%d\n", &n)
	for i := 0; i < n; i++ {
		solveProblem()
	}
}

func solveProblem() {
	var a, b, c, n int
	fmt.Scanf("%d %d %d %d\n", &a, &b, &c, &n)
	// fmt.Printf("%d %d %d %d\n", a, b, c, n)
	maxCoin := getMaxCoin(a, b, c)
	sack := []int{a - maxCoin, b - maxCoin, c - maxCoin}
	leftoverCoin := spreadCoin(n, sack)

	// fmt.Printf("%d %d %d %d => %d\n", a, b, c, n, leftoverCoin%3)
	if leftoverCoin >= 0 && leftoverCoin%3 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func getMaxCoin(a, b, c int) int {
	arr := []int{a, b, c}
	max := arr[0]
	for _, value := range arr {
		if value > max {
			max = value
		}
	}
	return max
}

func spreadCoin(n int, sack []int) (leftover int) {
	for _, coin := range sack {
		n += coin
	}
	return n
}

package main

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

func main() {
	var t, a, b, c, n int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &t)
	for i := 0; i < t; i++ {
		fmt.Fscan(in, &a, &b, &c, &n)
		m := max(a, b)
		m = max(m, c)
		sum := (m - a) + (m - b) + (m - c)
		if (n-sum)%3 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scanf("%d\n", &n)
	for i := 0; i < n; i++ {
		solveProblem()
	}
}

func solveProblem() {
	var a, b, c, n int
	fmt.Scanf("%d %d %d %d\n", &a, &b, &c, &n)
	// fmt.Printf("%d %d %d %d\n", a, b, c, n)
	maxCoin := getMaxCoin(a, b, c)
	sack := []int{a - maxCoin, b - maxCoin, c - maxCoin}
	leftoverCoin := spreadCoin(n, sack)

	// fmt.Printf("%d %d %d %d => %d\n", a, b, c, n, leftoverCoin%3)
	if leftoverCoin%3 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func getMaxCoin(a, b, c int) int {
	arr := []int{a, b, c}
	max := arr[0]
	for _, value := range arr {
		if value > max {
			max = value
		}
	}
	return max
}

func spreadCoin(n int, sack []int) (leftover int) {
	for _, coin := range sack {
		n += coin
	}
	return n
}

package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		solveProblem()
	}
}

func solveProblem() {
	var a, b, c, n int
	fmt.Scanf("%d %d %d %d", &a, &b, &c, &n)
	// fmt.Printf("%d %d %d %d\n", a, b, c, n)
	maxCoin := getMaxCoin(a, b, c)
	sack := []int{a - maxCoin, b - maxCoin, c - maxCoin}
	leftoverCoin := spreadCoin(n, sack)

	// fmt.Printf("%d %d %d %d => %d\n", a, b, c, n, leftoverCoin%3)
	if leftoverCoin%3 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func getMaxCoin(a, b, c int) int {
	arr := []int{a, b, c}
	max := arr[0]
	for _, value := range arr {
		if value > max {
			max = value
		}
	}
	return max
}

func spreadCoin(n int, sack []int) (leftover int) {
	for _, coin := range sack {
		n += coin
	}
	return n
}

package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		solveProblem()
	}
}

func solveProblem() {
	var a, b, c, n int
	fmt.Scanf("%d%d%d%d", &a, &b, &c, &n)
	// fmt.Printf("%d %d %d %d\n", a, b, c, n)
	maxCoin := getMaxCoin(a, b, c)
	sack := []int{a - maxCoin, b - maxCoin, c - maxCoin}
	leftoverCoin := spreadCoin(n, sack)

	// fmt.Printf("%d %d %d %d => %d\n", a, b, c, n, leftoverCoin%3)
	if leftoverCoin%3 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func getMaxCoin(a, b, c int) int {
	arr := []int{a, b, c}
	max := arr[0]
	for _, value := range arr {
		if value > max {
			max = value
		}
	}
	return max
}

func spreadCoin(n int, sack []int) (leftover int) {
	for _, coin := range sack {
		n += coin
	}
	return n
}

package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		solveProblem()
	}
}

func solveProblem() {
	var a, b, c, n int
	fmt.Scanf("%d %d %d %d\n", &a, &b, &c, &n)
	// fmt.Printf("%d %d %d %d\n", a, b, c, n)
	maxCoin := getMaxCoin(a, b, c)
	sack := []int{a - maxCoin, b - maxCoin, c - maxCoin}
	leftoverCoin := spreadCoin(n, sack)

	if leftoverCoin%3 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func getMaxCoin(a, b, c int) int {
	arr := []int{a, b, c}
	max := arr[0]
	for _, value := range arr {
		if value > max {
			max = value
		}
	}
	return max
}

func spreadCoin(n int, sack []int) (leftover int) {
	for _, coin := range sack {
		n += coin
	}
	return n
}

package main

import (
	"bufio"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	scanner.Split(bufio.ScanWords)
	scanner.Scan()
	t := toInt(scanner.Bytes())
	for t > 0 {
		a := getNum(scanner)
		b := getNum(scanner)
		c := getNum(scanner)
		n := getNum(scanner)
		max := max(a, b, c)
		diff := (max * 3) - (a + b + c)

		if n - diff > 0 && (n - diff) % 3 == 0 {
			writer.WriteString("YES\n")
		}else {
			writer.WriteString("NO\n")
		}
		t--
	}
}

func max(nums ...int) int {
	max := nums[0]
	for _, num := range nums {
		if num > max {
			max = num
		}
	}
	return max
}

func getNum(scanner *bufio.Scanner) int {
	scanner.Scan()
	return toInt(scanner.Bytes())
}

func toInt(buf []byte) int {
	v := 0
	for _, b := range buf {
		v = v * 10 + int(b - '0')
	}
	return v
}

package main

import (
	"bufio"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	scanner.Split(bufio.ScanWords)
	scanner.Scan()
	t := toInt(scanner.Bytes())
	for t > 0 {
		a := getNum(scanner)
		b := getNum(scanner)
		c := getNum(scanner)
		n := getNum(scanner)
		min, mid, max := getMinAvgMax(a, b, c)
		for n > 0 && min < mid {
			min++
			n--
		}
		for n > 1 && min < max && mid < max {
			min++
			mid++
			n -= 2
		}
		for n > 2 {
			min++
			mid++
			max++
			n -= 3
		}
		if min == max && mid == max && n == 0{
			writer.WriteString("YES\n")
		}else {
			writer.WriteString("NO\n")
		}
		t--
	}
}

func getMinAvgMax(a, b, c int) (int, int, int) {
	if a > b && a > c {
		if b > c {
			return c, b, a
		}else {
			return b, c, a
		}
	}
	if b > a && b > c {
		if a > c {
			return c, a, b
		}else {
			return a, c, b
		}
	}
	if c > a && b < c {
		if a < b {
			return a, b, c
		}else {
			return b, a, c
		}
	}
	return a, b, c

}

func getNum(scanner *bufio.Scanner) int {
	scanner.Scan()
	return toInt(scanner.Bytes())
}

func toInt(buf []byte) int {
	v := 0
	for _, b := range buf {
		v = v * 10 + int(b - '0')
	}
	return v
}

package main

import "fmt"

func max(a, b, c int) int {
	if a >= b && a >= c {
		return a
	}
	if b >= a && b >= c {
		return b
	}
	return c
}

func main() {
	var t int
	fmt.Scan(&t)
	for ; t > 0; t-- {
		var a, b, c, n int
		fmt.Scan(&a, &b, &c, &n)
		n -= 3*max(a, b, c) - a - b - c
		if n > 0 && n%3 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import "fmt"

func TwoRabbit(x, y, a, b int) string {
	if (y+x+a+b) % 3 == 0 { return "YES"}
	return "NO"
}

func main() {
	var n int
	fmt.Scanf("%d\n", &n)
	for i := 0; i < n; i++ {
		var x, y, a, b int
		fmt.Scanf("%d %d %d %d \n", &x, &y, &a, &b)
		fmt.Println(TwoRabbit(x, y, a, b))
	}
}

package main

import (
	"fmt"
)

func CollectingCoins(a, b, c, n int) string {
	sum := a+b+c+n
	if sum%3 == 0 {
		max := a
		if b > max {
			max = b
		}
		if c > max {
			max = c
		}
		if sum >= max {
			return "YES"
		}
	}
	return "NO"
}

func main() {
	var t int
	fmt.Scanf("%d\n", &t)
	for i := 0; i < t; i++ {
		var a, b, c, n int
		fmt.Scanf("%d %d %d %d \n", &a, &b, &c, &n)
		fmt.Println(CollectingCoins(a, b, c, n))
	}
}

package main

import "fmt"

func CollectingCoins(a, b, c, n int) string {
	if (a+b+c+n)%3 == 0 {
		return "YES"
	}
	return "NO"
}

func main() {
	var t int
	fmt.Scanf("%d\n", &t)
	for i := 0; i < t; i++ {
		var a, b, c, n int
		fmt.Scanf("%d %d %d %d \n", &a, &b, &c, &n)
		fmt.Println(CollectingCoins(a, b, c, n))
	}
}

// https://codeforces.com/problemset/problem/1294/A
package main

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

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

	var n int
	fmt.Fscanf(in, "%d\n", &n)
	for i := 0; i < n; i++ {
		var a, b, c, n int
		fmt.Fscanf(in, "%d%d%d%d\n", &a, &b, &c, &n)
		if a == b && a == c {
			if n%3 == 0 {
				fmt.Fprintln(out, "YES")
			} else {
				fmt.Fprintln(out, "NO")
			}
		} else {
			sum := n + a + b + c
			if sum%3 == 0 {
				fmt.Fprintln(out, "YES")
			} else {
				fmt.Fprintln(out, "NO")
			}
		}

	}
}

// https://codeforces.com/problemset/problem/1294/A
package main

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

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

	var n int
	fmt.Fscanf(in, "%d\n", &n)
	for i := 0; i < n; i++ {
		var p, a, b, c int
		fmt.Fscanf(in, "%d%d%d%d\n", &p, &a, &b, &c)
		sum := p + a + b + c
		if sum%3 == 0 {
			fmt.Fprintln(out, "YES")
		} else {
			fmt.Fprintln(out, "NO")
		}

	}
}

package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }

func main () {
	solution1294A()
}

func max(a,b int) int{
	if a>b {
		return a
	}
	return b
}
func solution1294A() {
	defer writer.Flush()

	var t,a,b,c,n int
	scanf("%d\n", &t)
	for  ;t>0; t--{
		scanf("%d %d %d %d\n", &a,&b,&c,&n)
		maxnum := max(a, max(b,c))
		temp := n - (3*maxnum - a - b - c)
		if (temp > 0 && temp % 3 == 0) {
			printf("YES\n")
		} else {
			printf("NO\n")
		}
	}
}

package main

import "fmt"

func main(){

	var t , a , b , c , n , sum int64

	fmt.Scan(&t)

	for T := 0 ; T < int(t) ; T ++ {
		fmt.Scan(&a,&b,&c,&n)
		sum = a + b + c + n
		if sum % 3 == 0 {
			sum /= 3
			if sum <= a && sum <= b && sum <= c {
				fmt.Println("YES")
			}else {
				fmt.Println("NO")
			}
		} else {
			fmt.Println("NO")
		}
	}

}

package main

import "fmt"

func main(){

	var t , a , b , c , n , sum int64

	fmt.Scan(&t)

	for T := 0 ; T < int(t) ; T ++ {
		fmt.Scan(&a,&b,&c,&n)
		sum = a + b + c + n
		if sum % 3 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}

}

package main

import (
	"fmt"
)

func main() {

	var t, a, i, b, c, n, ans int

	fmt.Scan(&t)

	for i = 0; i < t; i++ {

		fmt.Scan(&a, &b, &c, &n)

		ans = a + b + c + n

		if ans%3 != 0 || n%3 != 0 {
			fmt.Printf("NO\n")
		} else {
			fmt.Printf("YES\n")
		}
	}
}

package main

import (
	"fmt"
)

func main() {

	var t, a, i, b, c, n, ans int

	fmt.Scan(&t)

	for i = 0; i < t; i++ {

		fmt.Scan(&a, &b, &c, &n)

		ans = a + b + c + n

		if ans%3 != 0 {
			fmt.Printf("NO\n")
		} else {
			fmt.Printf("YES\n")
		}
	}
}

package main

import(

	"fmt"
)

func main(){

	var q int

	fmt.Scan(&q)

	for i := 0; i<q; i++ {

		var a[3] int
		var n int
		var sum int = 0

		fmt.Scan(&a[0])
		fmt.Scan(&a[1])
		fmt.Scan(&a[2])
		fmt.Scan(&n)

		sum = a[0] + a[1] + a[2] + n

		if sum % 3 == 1{
			fmt.Println("NO")
			continue
		}

		sum /= 3

		if sum >= a[0] && sum >= a[1] && sum >= a[2]{
			fmt.Println("YES")

		} else{
			fmt.Println("NO")

		}

	}

}

package main

import(

	"fmt"
)

func main(){

	var q int

	fmt.Scan(&q)

	for i := 0; i<q; i++ {

		var a[3] int64
		var n int64
		var sum int64 = 0

		fmt.Scan(&a[0])
		fmt.Scan(&a[1])
		fmt.Scan(&a[2])
		fmt.Scan(&n)

		sum = a[0] + a[1] + a[2] + n

		if sum % 3 == 1{
			fmt.Println("NO")
			continue
		}

		sum /= 3

		if sum >= a[0] && sum >= a[1] && sum >= a[2]{
			fmt.Println("YES")

		} else{
			fmt.Println("NO")

		}

	}

}

package main

import(

	"fmt"
)

func main(){

	var q int

	fmt.Scan(&q)

	for i := 0; i<q; i++ {

		var a, b, c int64
		var n int64
		var sum int64 = 0

		fmt.Scan(&a)
		fmt.Scan(&b)
		fmt.Scan(&c)
		fmt.Scan(&n)

		sum = a + b + c + n

		if sum % 3 == 1 {
			fmt.Println("NO")
			continue
		}

		sum /= 3

		if sum >= a && sum >= b && sum >= c {
			fmt.Println("YES")

		} else{
			fmt.Println("NO")

		}

	}

}

package main

import "fmt"

func check(a,b,c,n int) bool{
	n+=a+b+c
	if n%3!=0 {
		return false
	}
	if a>n/3 || b>n/3 ||c>n/3{
		return false
	}
	return true
}

func work(){
	var a,b,c,n int
	fmt.Scanf("%d%d%d%d",&a,&b,&c,&n);
	if check(a,b,c,n){
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func main(){
	var t int
	fmt.Scanf("%d",&t)
	for ;t>0;t--{
		work()
	}
}

package main

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

func run(r io.Reader, w io.Writer) {
	var in = bufio.NewReader(r)
	var out = bufio.NewWriter(w)
	defer out.Flush()

	var n int
	fmt.Fscanf(in, "%d\n", &n)

	var ss [][]int
	for i := 0; i < n; i++ {
		var num int
		var s []int
		for j := 0; j < 4; j++ {
			fmt.Fscanf(in, "%d ", &num)
			s = append(s, num)
		}
		ss = append(ss, s)
	}

	var tempS = 0
	for i := 0; i < n; i++ {
		var n = ss[i][3]
		var isBr = false
		for j := 0; j < 3; j++ {
			if t := n - ss[i][j]; t < 0 {
				fmt.Fprintf(out, "NO\n")
				isBr = true
				break
			} else {
				tempS += t
			}
		}
		if isBr {
			continue
		}
		if abs(n-tempS)%3 == 0 {
			fmt.Fprintf(out, "YES\n")
		}
		tempS = 0
		//else {
		//	fmt.Fprintf(out, "NO\n")
		//}
	}
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func main() {
	run(os.Stdin, os.Stdout)
}

package main

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

func run(r io.Reader, w io.Writer) {
	var in = bufio.NewReader(r)
	var out = bufio.NewWriter(w)
	defer out.Flush()

	var n int
	fmt.Fscanf(in, "%d\n", &n)

	var ss [][]int
	for i := 0; i < n; i++ {
		var num int
		var s []int
		for j := 0; j < 4; j++ {
			fmt.Fscanf(in, "%d ", &num)
			s = append(s, num)
		}
		ss = append(ss, s)
	}

	var tempS = 0
	for i := 0; i < n; i++ {
		var n = ss[i][3]
		for j := 0; j < 3; j++ {
			if t := n - ss[i][j]; t < 0 {
				break
			} else {
				tempS += t
			}
		}
		if abs(n-tempS)%3 == 0 {
			fmt.Fprintf(out, "YES\n")
		} else {
			fmt.Fprintf(out, "NO\n")
		}
		tempS = 0
	}
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func main() {
	run(os.Stdin, os.Stdout)
}

package main

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

func run(r io.Reader, w io.Writer) {
	var in = bufio.NewReader(r)
	var out = bufio.NewWriter(w)
	defer out.Flush()

	var n int
	fmt.Fscanf(in, "%d\n", &n)

	var ss [][]int
	for i := 0; i < n; i++ {
		var num int
		var s []int
		for j := 0; j < 4; j++ {
			fmt.Fscanf(in, "%d", &num)
			s = append(s, num)
		}
		ss = append(ss, s)
	}

	var tempS = 0
	for i := 0; i < n; i++ {
		var n = ss[i][3]
		for j := 0; j < 3; j++ {
			if t := n - ss[i][j]; t < 0 {
				break
			} else {
				tempS += t
			}
		}
		if abs(n-tempS)%3 == 0 {
			fmt.Fprintf(out, "YES\n")
		} else {
			fmt.Fprintf(out, "NO\n")
		}
		tempS = 0
	}
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func main() {
	run(os.Stdin, os.Stdout)
}

package main

import "fmt"

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func main() {
	var T int
	fmt.Scan(&T)
	for t := 0; t < T; t++ {
		var a, b, c, n int
		fmt.Scan(&a, &b, &c, &n)
		tmp := max(a, max(b, c))
		n -= tmp - a
		a = tmp
		n -= tmp - b
		b = tmp
		n -= tmp - c
		c = tmp
		if n >= 0 && n%3 == 0 {
			println("YES")
		} else {
			println("NO")
		}
	}
}

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"sync"
)

const (
	MX_INT int64 = math.MaxInt64
	MN_INT int64 = math.MinInt64
)

func main() {
	for t := ScanInt64(); t > 0; t-- {
		a, b, c, n := ScanInt64(), ScanInt64(), ScanInt64(), ScanInt64()
		initCoin := []int64{a, b, c}
		sort.Slice(initCoin, func(i, j int) bool { return initCoin[i] < initCoin[j] })

		adiff := initCoin[2] - initCoin[0]
		n -= adiff

		bdiff := initCoin[2] - initCoin[1]
		n -= bdiff

		if n%3 == 0 {
			Pl("YES")
		} else {
			Pl("NO")
		}
	}
	close(O)
	oWg.Wait()
}

/*********************** I/O ***********************/

var O chan string
var in *bufio.Scanner
var oWg *sync.WaitGroup
var Pl func(a ...interface{}) (n int, err error)

func init() {
	Pl = fmt.Println

	in = bufio.NewScanner(os.Stdin)
	in.Buffer(make([]byte, 1024), int(1e9))
	in.Split(bufio.ScanWords)

	O = make(chan string, 16)
	oWg = &sync.WaitGroup{}
	oWg.Add(1)

	writer := bufio.NewWriterSize(os.Stdout, int(2e+5))
	go func(writer *bufio.Writer) {
		defer oWg.Done()
		defer writer.Flush()

		for line := range O {
			writer.WriteString(line + "\n")
		}
	}(writer)
}

func ScanWord() string {
	in.Scan()
	return in.Text()
}

func ScanStringSlice(n int64) []string {
	length := int(n)
	s := make([]string, n)
	for i := 0; i < length; i++ {
		s[i] = ScanWord()
	}
	return s
}

func ScanInt64() int64 {
	intStr := ScanWord()
	i, err := strconv.ParseInt(intStr, 10, 64)
	if err != nil {
		panic(err)
	}
	return i
}

func ScanInt() int {
	intStr := ScanWord()
	i, err := strconv.Atoi(intStr)
	if err != nil {
		panic(err)
	}
	return i
}

func ScanInt64Slice(n int64) []int64 {
	length := int(n)
	arr := make([]int64, n)
	for i := 0; i < length; i++ {
		arr[i] = ScanInt64()
	}
	return arr
}

/*********************** Utils ***********************/

func Mx(args ...int64) int64 {
	maxVal := MN_INT
	for _, v := range args {
		if v > maxVal {
			maxVal = v
		}
	}
	return maxVal
}

func Mn(args ...int64) int64 {
	minVal := MX_INT
	for _, v := range args {
		if v < minVal {
			minVal = v
		}
	}
	return minVal
}

func LCM(a, b int64) int64 {
	return a / GCD(a, b) * b
}

func GCD(a, b int64) int64 {
	if (a == 0) {
		return b
	}
	return GCD(b%a, a)
}

func S(v interface{}) string {
	return fmt.Sprintf("%v", v)
}

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"sync"
)

const (
	MX_INT int64 = math.MaxInt64
	MN_INT int64 = math.MinInt64
)

func main() {
	for t := ScanInt64(); t > 0; t-- {
		a, b, c, n := ScanInt64(), ScanInt64(), ScanInt64(), ScanInt64()
		initCoin := []int64{a, b, c}
		sort.Slice(initCoin, func(i, j int) bool { return initCoin[i] < initCoin[j] })

		adiff := initCoin[2] - initCoin[0]
		n -= adiff

		bdiff := initCoin[2] - initCoin[1]
		n -= bdiff

		if n%3 == 0 {
			Pl("YES")
		} else {
			Pl("NO")
		}
	}
	close(O)
	oWg.Wait()
}

/*********************** I/O ***********************/

var O chan string
var in *bufio.Scanner
var oWg *sync.WaitGroup
var Pl func(a ...interface{}) (n int, err error)

func init() {
	Pl = fmt.Println

	in = bufio.NewScanner(os.Stdin)
	in.Buffer(make([]byte, 1024), int(1e+8))
	in.Split(bufio.ScanWords)

	O = make(chan string, 16)
	oWg = &sync.WaitGroup{}
	oWg.Add(1)

	writer := bufio.NewWriterSize(os.Stdout, int(2e+5))
	go func(writer *bufio.Writer) {
		defer oWg.Done()
		defer writer.Flush()

		for line := range O {
			writer.WriteString(line + "\n")
		}
	}(writer)
}

func ScanWord() string {
	in.Scan()
	return in.Text()
}

func ScanStringSlice(n int64) []string {
	length := int(n)
	s := make([]string, n)
	for i := 0; i < length; i++ {
		s[i] = ScanWord()
	}
	return s
}

func ScanInt64() int64 {
	intStr := ScanWord()
	i, err := strconv.ParseInt(intStr, 10, 64)
	if err != nil {
		panic(err)
	}
	return i
}

func ScanInt() int {
	intStr := ScanWord()
	i, err := strconv.Atoi(intStr)
	if err != nil {
		panic(err)
	}
	return i
}

func ScanInt64Slice(n int64) []int64 {
	length := int(n)
	arr := make([]int64, n)
	for i := 0; i < length; i++ {
		arr[i] = ScanInt64()
	}
	return arr
}

/*********************** Utils ***********************/

func Mx(args ...int64) int64 {
	maxVal := MN_INT
	for _, v := range args {
		if v > maxVal {
			maxVal = v
		}
	}
	return maxVal
}

func Mn(args ...int64) int64 {
	minVal := MX_INT
	for _, v := range args {
		if v < minVal {
			minVal = v
		}
	}
	return minVal
}

func LCM(a, b int64) int64 {
	return a / GCD(a, b) * b
}

func GCD(a, b int64) int64 {
	if (a == 0) {
		return b
	}
	return GCD(b%a, a)
}

func S(v interface{}) string {
	return fmt.Sprintf("%v", v)
}

package main

import (
	"fmt"
)

func main() {
	var t int64
	fmt.Scan(&t)
	for i := int64(0); i < t; i++ {
		var a, b, c, n int64
		fmt.Scan(&a,&b,&c,&n)
		result := a+b+c+n
		if result%3 == 0 && result >= a && result >= b && result >= c{
			fmt.Println("YES")
		}else{
			fmt.Println("NO")
		}
	}
}

package main
import (
	"fmt"
	"bufio"
	"os"
	"strings"
)
func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var t int
	fmt.Fscan(in, &t)
	ans := make([]string, t)
	for i := 0; i < t; i++ {
		var a, b, c, n int
		fmt.Fscan(in, &a, &b, &c, &n)
		m := a
		if m < b {
			m = b
		}
		if m < c {
			m = c
		}
		s := 3 * m - a - b - c

		if n > s && (n - s)%3 == 0 {
			ans[i] = "YES"
		} else {
			ans[i] = "NO"
		}

	}
	fmt.Fprintln(out, strings.Join(ans, "\n"))

}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func scanIntArr() ([]int, error) {
	str, err := reader.ReadString('\n')
	if err != nil {
		return nil, err
	}
	str = strings.TrimRight(str, "\n\r")
	strArr := strings.Split(str, " ")

	arr := make([]int, len(strArr))
	for i, strA := range strArr {
		arr[i], err = strconv.Atoi(strA)
		if err != nil {
			return nil, err
		}
	}

	return arr, nil
}

func main() {
	defer writer.Flush()

	var t int
	scanf("%d\n", &t)

	for i := 0; i < t; i++ {
		exec()
	}
}

func exec() {
	var n uint64
	scanf("%d %d\n", &n)

	printf("%d\n", n)
}

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"strings"
	"sync"
)

func main() {

	t := ScanInt64()
	for ; t > 0; t-- {
		n := ScanInt64()
		fmt.Println(n)
	}

}

/*********************** I/O ***********************/

var O chan string
var in *bufio.Scanner
var oWg *sync.WaitGroup
var P func(a ...interface{}) (n int, err error)

func init() {
	P = fmt.Println

	in = bufio.NewScanner(os.Stdin)
	in.Buffer(make([]byte, 1024), int(1e+9))
	in.Split(bufio.ScanWords)

	O = make(chan string, 16)
	oWg = &sync.WaitGroup{}
	oWg.Add(1)

	writer := bufio.NewWriter(os.Stdout)
	go func() {
		defer oWg.Done()
		defer writer.Flush()

		for line := range O {
			writer.WriteString(line + "\n")
		}
	}()
}

func ScanWord() string { in.Scan(); return in.Text() }
func ScanInt() int     { i, _ := strconv.Atoi(ScanWord()); return i }
func ScanInt64() int64 { i, _ := strconv.ParseInt(ScanWord(), 10, 64); return i }
func ScanStringSlice(n int) []string {
	s := make([]string, n)
	for i := 0; i < n; i++ {
		s[i] = ScanWord()
	}
	return s
}
func ScanIntSlice(n int) []int {
	arr := make([]int, n)
	for i := 0; i < n; i++ {
		arr[i] = ScanInt()
	}
	return arr
}
func ScanInt64Slice(n int) []int64 {
	arr := make([]int64, n)
	for i := 0; i < n; i++ {
		arr[i] = ScanInt64()
	}
	return arr
}

/*********************** Utils ***********************/

func S(v interface{}) string { return fmt.Sprintf("%v", v) }
func SArr(a []int) string {
	sb := strings.Builder{}
	sb.Grow(len(a) * 9)
	for i := range a {
		sb.WriteString(strconv.Itoa(a[i]) + " ")
	}
	return sb.String()
}
func SArr64(a []int64) string {
	sb := strings.Builder{}
	sb.Grow(len(a) * 9)
	for i := range a {
		sb.WriteString(strconv.FormatInt(a[i], 10) + " ")
	}
	return sb.String()
}
func MnMx(args []int64) (int64, int64) {
	minVal, maxVal := int64(math.MaxInt64), int64(math.MinInt64)
	for _, v := range args {
		if v < minVal {
			minVal = v
		}
		if v > maxVal {
			maxVal = v
		}
	}
	return minVal, maxVal
}
func Mn(args []int64) int64 { mn, _ := MnMx(args); return mn }
func Mx(args []int64) int64 { _, mx := MnMx(args); return mx }
func LCM(a, b int64) int64  { return a / GCD(a, b) * b }
func GCD(a, b int64) int64 {
	if a == 0 {
		return b
	}
	return GCD(b%a, a)
}
func sortInt64Slice(a []int64) { sort.Slice(a, func(i, j int) bool { return a[i] < a[j] }) }
func abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}
func MinimumMaximum(a, b int64) (int64, int64) {
	if a < b {
		return a, b
	}
	return b, a

}
func Minimum(a, b int64) int64 {
	min, _ := MinimumMaximum(a, b)
	return min

}
func Maximum(a, b int64) int64 {
	_, max := MinimumMaximum(a, b)
	return max

}

package main

import (
	"fmt"
)

func main() {
	// Parse test input
	var N int
	fmt.Scan(&N)
	var i int
	var x int
	for i = 0; i < N; i++ {
		fmt.Scan(&x)
		fmt.Println(x)
	}

}

package main

import (
	"bufio"
	"fmt"
)

func main() {
	var cases int
	fmt.Scanf("%d\n", &cases)
	for i := 0; i < cases; i++ {
		var n int64
		fmt.Scanf("%d\n", &n)
		fmt.Println(n)
	}
}

func readLine(reader *bufio.Reader) []byte {
	result := make([]byte, 0)
	for {
		s, isPrefix, err := reader.ReadLine()
		if err != nil {
			fmt.Printf("error=%+v\n", err)
			break
		}
		result = append(result, s...)
		if !isPrefix {
			break
		}
	}
	return result
}

package main

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

var n int
var nt int

func main() {
	var reader = bufio.NewReader(os.Stdin)
	var writer = bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	fmt.Fscanf(reader, "%d\n", &nt)
	for k := 0; k < nt; k++ {
		fmt.Fscanf(reader, "%d\n", &n)
		fmt.Fprintf(writer, "%d\n", n)
	}
}

// https://serhatgiydiren.github.io

package main

import "fmt"
import "os"
import "bufio"

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func solve(test_id int) {
 var n int
 fmt.Fscanf(reader, "%d\n", &n)
 fmt.Fprintf(writer, "%d\n", n)
}

func solve_cases() {
 defer writer.Flush()
 t := 1
 fmt.Fscanf(reader, "%d\n", &t)
 for i := 0 ; i < t ; i++ {
  solve(i)
 }
}

func main() {
 solve_cases()
}

package main

import (
	"fmt"
)

func minVal(a, b int) int {
	if a <= b {
		return a
	}
	return b
}

func maxVal(a, b int) int {
	if a >= b {
		return a
	}
	return b
}

func max(arr []int) (max int) {
	max = arr[0]
	for _, val := range arr {
		if val > max {
			max = val
		}
	}
	return max
}

func main() {
	var t int
	fmt.Scan(&t)
	for qt := 0; qt < t; qt++ {
		var n int
		fmt.Scan(&n)
		fmt.Println(n)
	}
}

package main

import (
	"fmt"
)

func main(){
	var t int
	fmt.Scanln(&t)
	for t>0 {
		t--
		var n int
		fmt.Scanln(&n)
		fmt.Println(n)
	}
}

package main

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

type BufferedWriter interface {
	Printf(format string, a ...interface{})
	Flush()
}

type writerImpl struct {
	*bufio.Writer
}

func NewBufferedWriter(writer io.Writer) BufferedWriter {
	return &writerImpl{Writer: bufio.NewWriter(writer)}
}

func (impl *writerImpl) Printf(f string, a ...interface{}) {
	fmt.Fprintf(impl.Writer, f, a...)
}

func (impl *writerImpl) Flush() {
	impl.Writer.Flush()
}

type WordScanner interface {
	NextInt() int
	NextInt64() int64
	NextString() string
}

type wordScannerImpl struct {
	*bufio.Scanner
}

func NewWordScanner(reader io.Reader) WordScanner {
	s := bufio.NewScanner(reader)
	s.Split(bufio.ScanWords)
	// adjust the following size as needed
	// 2 << 17 is good enough to scan strings of len 2*10^5
	// it could go as high as 2 << 26 before cf judge breaks
	size := 2 << 20
	buf := make([]byte, size)
	s.Buffer(buf, size)
	return &wordScannerImpl{Scanner: s}
}

func (impl *wordScannerImpl) NextInt() int {
	impl.Scan()
	bb := impl.Bytes()
	i := 0
	if bb[0] == '-' {
		for _, b := range bb[1:] {
			i *= 10
			i -= int(b - '0')
		}
		return i
	}
	for _, b := range bb {
		i *= 10
		i += int(b - '0')
	}
	return i
}

func (impl *wordScannerImpl) NextInt64() int64 {
	impl.Scan()
	bb := impl.Bytes()
	i := int64(0)
	if bb[0] == '-' {
		for _, b := range bb[1:] {
			i *= 10
			i -= int64(b - '0')
		}
		return i
	}
	for _, b := range bb {
		i *= 10
		i += int64(b - '0')
	}
	return i
}

func (impl *wordScannerImpl) NextString() string {
	impl.Scan()
	return impl.Text()
}

var reader = NewWordScanner(os.Stdin)
var writer = NewBufferedWriter(os.Stdout)

func main() {
	defer writer.Flush()
	t := reader.NextInt64()
	for ; t > 0; t-- {
		n := reader.NextInt64()
        writer.Printf("%d\n", n)
	}
}

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"strings"
	"sync"
)

func main() {

	t := ScanInt64()
	for ; t > 0; t-- {
		n := ScanInt64()
		if n == 1 {
			fmt.Println(1)
		} else {
			fmt.Println(2)
		}
	}

}

/*********************** I/O ***********************/

var O chan string
var in *bufio.Scanner
var oWg *sync.WaitGroup
var P func(a ...interface{}) (n int, err error)

func init() {
	P = fmt.Println

	in = bufio.NewScanner(os.Stdin)
	in.Buffer(make([]byte, 1024), int(1e+9))
	in.Split(bufio.ScanWords)

	O = make(chan string, 16)
	oWg = &sync.WaitGroup{}
	oWg.Add(1)

	writer := bufio.NewWriter(os.Stdout)
	go func() {
		defer oWg.Done()
		defer writer.Flush()

		for line := range O {
			writer.WriteString(line + "\n")
		}
	}()
}

func ScanWord() string { in.Scan(); return in.Text() }
func ScanInt() int     { i, _ := strconv.Atoi(ScanWord()); return i }
func ScanInt64() int64 { i, _ := strconv.ParseInt(ScanWord(), 10, 64); return i }
func ScanStringSlice(n int) []string {
	s := make([]string, n)
	for i := 0; i < n; i++ {
		s[i] = ScanWord()
	}
	return s
}
func ScanIntSlice(n int) []int {
	arr := make([]int, n)
	for i := 0; i < n; i++ {
		arr[i] = ScanInt()
	}
	return arr
}
func ScanInt64Slice(n int) []int64 {
	arr := make([]int64, n)
	for i := 0; i < n; i++ {
		arr[i] = ScanInt64()
	}
	return arr
}

/*********************** Utils ***********************/

func S(v interface{}) string { return fmt.Sprintf("%v", v) }
func SArr(a []int) string {
	sb := strings.Builder{}
	sb.Grow(len(a) * 9)
	for i := range a {
		sb.WriteString(strconv.Itoa(a[i]) + " ")
	}
	return sb.String()
}
func SArr64(a []int64) string {
	sb := strings.Builder{}
	sb.Grow(len(a) * 9)
	for i := range a {
		sb.WriteString(strconv.FormatInt(a[i], 10) + " ")
	}
	return sb.String()
}
func MnMx(args []int64) (int64, int64) {
	minVal, maxVal := int64(math.MaxInt64), int64(math.MinInt64)
	for _, v := range args {
		if v < minVal {
			minVal = v
		}
		if v > maxVal {
			maxVal = v
		}
	}
	return minVal, maxVal
}
func Mn(args []int64) int64 { mn, _ := MnMx(args); return mn }
func Mx(args []int64) int64 { _, mx := MnMx(args); return mx }
func LCM(a, b int64) int64  { return a / GCD(a, b) * b }
func GCD(a, b int64) int64 {
	if a == 0 {
		return b
	}
	return GCD(b%a, a)
}
func sortInt64Slice(a []int64) { sort.Slice(a, func(i, j int) bool { return a[i] < a[j] }) }
func abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}
func MinimumMaximum(a, b int64) (int64, int64) {
	if a < b {
		return a, b
	}
	return b, a

}
func Minimum(a, b int64) int64 {
	min, _ := MinimumMaximum(a, b)
	return min

}
func Maximum(a, b int64) int64 {
	_, max := MinimumMaximum(a, b)
	return max

}

package main

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	"strings"
)

func GetInt(reader *bufio.Reader) (int64) {
	text, _ := reader.ReadString('\n')
	N, _ := strconv.ParseInt(strings.Trim(text,"\n"), 10, 64)
	return N
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := os.Stdout

	// Parse test input
	N := GetInt(in)
	var i int64
	for i = 0; i < N; i++ {
		x := GetInt(in)
		fmt.Fprintln(out, x)
	}

}

package main

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	"strings"
)

func GetInt(reader *bufio.Reader) (int64) {
	text, _ := reader.ReadString('\n')
	N, _ := strconv.ParseInt(strings.Trim(text,"\n"), 10, 64)
	return N
}

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Parse test input
	N := GetInt(reader)
	var i int64
	for i = 0; i < N; i++ {
		x := GetInt(reader)
		if i != 0 {
			fmt.Println()
		}
		fmt.Print(x)
	}

}

package main

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	"strings"
)

func GetInt(reader *bufio.Reader) (int64) {
	text, _ := reader.ReadString('\n')
	N, _ := strconv.ParseInt(strings.Trim(text,"\n"), 10, 64)
	return N
}

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Parse test input
	N := GetInt(reader)
	var i int64
	for i = 0; i < N; i++ {
		x := GetInt(reader)
		fmt.Println(x)
	}

}

package main

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	"strings"
)

func GetInt(reader *bufio.Reader) (int64) {
	text, _ := reader.ReadString('\n')
	N, _ := strconv.ParseInt(strings.Trim(text,"\n"), 10, 64)
	return N
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := os.Stderr

	// Parse test input
	N := GetInt(in)
	var i int64
	for i = 0; i < N; i++ {
		x := GetInt(in)
		fmt.Fprintln(out, x)
	}

}

package main

import (
	"fmt"
)

func main() {
	fmt.Println(2)
	fmt.Println(1)
}

package main

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

type BufferedWriter interface {
	Printf(format string, a ...interface{})
	Flush()
}

type writerImpl struct {
	*bufio.Writer
}

func NewBufferedWriter(writer io.Writer) BufferedWriter {
	return &writerImpl{Writer: bufio.NewWriter(writer)}
}

func (impl *writerImpl) Printf(f string, a ...interface{}) {
	fmt.Fprintf(impl.Writer, f, a...)
}

func (impl *writerImpl) Flush() {
	impl.Writer.Flush()
}

type WordScanner interface {
	NextInt() int
	NextInt64() int64
	NextString() string
}

type wordScannerImpl struct {
	*bufio.Scanner
}

func NewWordScanner(reader io.Reader) WordScanner {
	s := bufio.NewScanner(reader)
	s.Split(bufio.ScanWords)
	// adjust the following size as needed
	// 2 << 17 is good enough to scan strings of len 2*10^5
	// it could go as high as 2 << 26 before cf judge breaks
	size := 2 << 20
	buf := make([]byte, size)
	s.Buffer(buf, size)
	return &wordScannerImpl{Scanner: s}
}

func (impl *wordScannerImpl) NextInt() int {
	impl.Scan()
	bb := impl.Bytes()
	i := 0
	if bb[0] == '-' {
		for _, b := range bb[1:] {
			i *= 10
			i -= int(b - '0')
		}
		return i
	}
	for _, b := range bb {
		i *= 10
		i += int(b - '0')
	}
	return i
}

func (impl *wordScannerImpl) NextInt64() int64 {
	impl.Scan()
	bb := impl.Bytes()
	i := int64(0)
	if bb[0] == '-' {
		for _, b := range bb[1:] {
			i *= 10
			i -= int64(b - '0')
		}
		return i
	}
	for _, b := range bb {
		i *= 10
		i += int64(b - '0')
	}
	return i
}

func (impl *wordScannerImpl) NextString() string {
	impl.Scan()
	return impl.Text()
}

var reader = NewWordScanner(os.Stdin)
var writer = NewBufferedWriter(os.Stdout)

func main() {
	defer writer.Flush()
	t := reader.NextInt64()
	for ; t > 0; t-- {
		n := reader.NextInt64()
		if n == 1 {
			writer.Printf("1\n")
		} else {
			writer.Printf("2\n")
		}
	}
}


package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var t int
	fmt.Fscan(in, &t)
	for t > 0 {
		var n int
		var x uint64
		fmt.Fscan(in, &n, &x)
		var mn, mx uint64
		for i := 0; i < n; i++ {
			var num uint64
			fmt.Fscan(in, &num)
			mn += num
			mx += (num + x - 1) / x
		}
		mn = (mn + x - 1) / x
		fmt.Println(mn, mx)
		t--
	}

}

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"strings"
)

var sc = bufio.NewScanner(os.Stdin)
var wr = bufio.NewWriter(os.Stdout)

func main() {
	defer wr.Flush()
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 4096), 1e9)
	// this template is new version.
	// use getI(), getS(), getInts(), getF()
	for i := getI(); i > 0; i-- {
		n, x := getI(), getI()
		a := getInts(n)
		min := int64(math.Ceil(float64(nsum(a...)) / float64(x)))
		var max int64
		for _, num := range a {
			max += int64(math.Ceil(float64(num) / float64(x)))
		}
		printf("%d %d\n", min, max)
	}
}

// !------- HELPERS -------!

func out(x ...interface{}) {
	fmt.Fprintln(wr, x...)
}

func printf(f string, a ...interface{}) {
	fmt.Fprintf(wr, f, a...)
}

func getI() int64 {
	s := getS()
	i := int64(0)
	if s[0] == '-' {
		for _, r := range s[1:] {
			i *= 10
			i -= int64(r - '0')
		}
		return i
	}
	for _, r := range s {
		i *= 10
		i += int64(r - '0')
	}
	return i
}

func getF() float64 {
	sc.Scan()
	i, e := strconv.ParseFloat(sc.Text(), 64)
	if e != nil {
		panic(e)
	}
	return i
}

func getInts(N int64) []int64 {
	ret := make([]int64, N)
	for i := range ret {
		ret[i] = getI()
	}
	return ret
}

func getS() string {
	if !sc.Scan() {
		panic(sc.Err())
	}
	return sc.Text()
}

func nsort(data ...int64) {
	sort.Slice(data, func(i, j int) bool { return data[i] < data[j] })
}

func nsum(data ...int64) int64 {
	var res int64
	for _, n := range data {
		res += n
	}
	return res
}

func njoin(s ...int64) string {
	return strings.Trim(fmt.Sprintf("%v", s), "[]")
}

func forEach(n int64, fn func(int64)) {
	for i := int64(0); i < n; i++ {
		fn(i)
	}
}

// min, max, asub, abs
func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

// min for n entry
func nmin(a ...int64) int64 {
	ret := a[0]
	for _, e := range a {
		ret = min(ret, e)
	}
	return ret
}

// max for n entry
func nmax(a ...int64) int64 {
	ret := a[0]
	for _, e := range a {
		ret = max(ret, e)
	}
	return ret
}

func asub(a, b int64) int64 {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int64) int64 {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int64, x int64) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int64, x int64) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

package main
import (
"bufio"
"fmt"
"io"
"os"
)

func FUG(n, x int64) int64{
if n%x ==0{
return n/x
}else{
H := (n - (n%x) + x)/x
return H
}
}

func main() {

var input io.Reader = bufio.NewReader(os.Stdin)
var t int
fmt.Fscan(input, &t)

for o:=0;o<t;o++{
var n, x int
fmt.Fscan(input, &n)
fmt.Fscan(input, &x)

ARRAY := make([]int, n)
for i:=0; i<n;i++{
fmt.Fscan(input, &ARRAY[i])
}
var SUM int64
for m :=0; m< n; m++{
SUM = SUM + int64(ARRAY[m])
}

var MIN int64
var MAX int64

MIN = FUG(SUM, int64(x))
for k :=0; k< n;k++{
MAX = MAX + FUG(int64(ARRAY[k]), int64(x))
}
fmt.Print(MIN, " ")
fmt.Print(MAX, " ")
fmt.Println()
}
}

package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"os"
	"strings"
)

var bytes []byte

func nextByte() byte {
	b := bytes[0]
	bytes = bytes[1:]
	return b
}

func ScanInt64() int64 {
	var negative bool
	var result int64

	b := nextByte()

	for ; b < '0' || b > '9'; b = nextByte() {
		if b == '-' {
			negative = true
		}
	}

	for ; '0' <= b && b <= '9'; b = nextByte() {
		result = (result << 3) + (result << 1) + int64(b-'0')
	}

	if negative {
		return -result
	} else {
		return result
	}
}

func ScanInt() int {
	return int(ScanInt64())
}

func ScanString() string {
	builder := strings.Builder{}

	for b := nextByte(); b != '\r'; b = nextByte() {
		if b != '\n' {
			builder.WriteByte(b)
		}
	}

	return builder.String()
}

func init() {
	f, err := os.Open("in.txt")

	if err == nil {
		defer f.Close()
	} else {
		f = os.Stdin
	}

	bytes, _ = ioutil.ReadAll(bufio.NewReader(f))
}

func main() {
	for t := ScanInt(); t > 0; t-- {
		n, x := ScanInt(), ScanInt64()
		var min, max, sum int64

		for i := 0; i < n; i++ {
			a := ScanInt64()

			sum += a

			max += a / x
			if a%x > 0 {
				max++
			}
		}

		min = sum / x
		if sum%x > 0 {
			min++
		}

		fmt.Println(min, max)
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
)
var (
    input = bufio.NewReader(os.Stdin)
    output = bufio.NewWriter(os.Stdout)
)

func assert(test bool) {
    if !test {panic("assertion!")}
}

// (c) Dmitriy Blokhin (sv.dblokhin@gmail.com)
func main() {
    var t int
	fmt.Fscan(input, &t)
    for t > 0 {
        t--
        solve()
    }
    output.Flush()
}

func solve() {
    var n, x int64
    fmt.Fscan(input, &n, &x)
    a := make([]int64, n)
    sum, ma := int64(0), int64(0)
    for i := 0; i < len(a); i++ {
        fmt.Fscan(input, &a[i])
        ma += (a[i] - 1) / x + 1
        sum += a[i]
    }

    fmt.Fprintln(output, (sum - 1) / x + 1, ma)
}

func min(a, b int) int {
    if a < b { return a}
    return b
}

package main

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

var (
	in  = bufio.NewReader(os.Stdin)
	out = bufio.NewWriter(os.Stdout)
	t   int
	n   int
	x   float64
)

func main() {

	defer out.Flush()

	fmt.Fscan(in, &t)

	for ; t > 0; t-- {

		fmt.Fscan(in, &n, &x)
		a := make([]float64, n)

		sum := float64(0)
		for i := range a {
			fmt.Fscan(in, &a[i])
			sum += a[i]
		}

		solve(a, n, x, sum)

	}

}

func solve(a []float64, n int, x float64, sum float64) {

	min := math.Ceil(sum / x)
	max := float64(0)

	for i := range a {
		max += math.Ceil(a[i] / x)
	}

	fmt.Fprintf(out, "%.0f %.0f\n", min, max)

}

//取絕對值
func abs(n int) int {
	if n >= 0 {
		return n
	} else {
		return -n
	}
}

//印出數字陣列
func printArr(array []int) {

	for i := range array {
		fmt.Printf("%d ", array[i])
	}

	fmt.Println()

}

package main

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

func ceil(a, b int64) int64 {
	if a%b == 0 {
		return a / b
	}
	return a/b + 1
}

func main() {
	in := bufio.NewReader(os.Stdin)

	var t, n, x, a int64
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		fmt.Fscan(in, &n, &x)
		minSum := int64(0)
		maxSum := int64(0)
		for i := int64(0); i < n; i++ {
			fmt.Fscan(in, &a)
			minSum += a
			maxSum += ceil(a, x)
		}

		fmt.Println(ceil(minSum, x), maxSum)
	}
}

package main

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

var (
	writer  = bufio.NewWriter(os.Stdout)
	scanner = bufio.NewScanner(os.Stdin)
)

func init() {
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1e6), 1e6)
}

func printf(f string, a ...interface{}) {
	fmt.Fprintf(writer, f, a...)
}

func sint64() int64 {
	scanner.Scan()
	bb := scanner.Bytes()
	i := int64(0)
	if bb[0] == '-' {
		for _, b := range bb[1:] {
			i *= 10
			i -= int64(b - '0')
		}
		return i
	}
	for _, b := range bb {
		i *= 10
		i += int64(b - '0')
	}
	return i
}

func suint64() uint64 {
	scanner.Scan()
	bb := scanner.Bytes()
	i := uint64(0)
	for _, b := range bb {
		i *= 10
		i += uint64(b - '0')
	}
	return i
}

func sstring() string {
	scanner.Scan()
	return scanner.Text()
}

func sbytes() []byte {
	scanner.Scan()
	return scanner.Bytes()
}

func main() {
	defer writer.Flush()
	for t := sint64(); t > 0; t-- {
		n := sint64()
		x := sint64()
		a := make([]int64, n)
		for i := range a {
			a[i] = sint64()
		}
		printf("%d %d\n", solveMin(a, x), solveMax(a, x))
	}
}

func solveMin(a []int64, x int64) int64 {
	sum := int64(0)
	for _, n := range a {
		sum += n
	}
	return ceilDiv(sum, x)
}

func solveMax(a []int64, x int64) int64 {
	ret := int64(0)
	for _, n := range a {
		ret += ceilDiv(n, x)
	}
	return ret
}

func ceilDiv(a, b int64) int64 {
	if a%b == 0 {
		return a / b
	}
	return a/b + 1
}

package main

import (
	"bufio"
	. "fmt"
	"io"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func CF1471A(_r io.Reader, _w io.Writer) {
	in := bufio.NewReader(_r)
	out := bufio.NewWriter(_w)
	defer out.Flush()

	var T, n int
	for Fscan(in, &T); T > 0; T-- {
		var mi, mx, x, v int64
		for Fscan(in, &n, &x); n > 0; n-- {
			Fscan(in, &v)
			mi += v
			mx += (v-1)/x + 1
		}
		Fprintln(out, (mi-1)/x+1, mx)
	}
}

func main() { CF1471A(os.Stdin, os.Stdout) }

// 1471A. Strange Partition
package main

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

func main() {
	var T int
	reader := bufio.NewReader(os.Stdin)
	fmt.Fscan(reader, &T)
	for t := 1; t <= T; t++ {
		var n, x int
		fmt.Fscan(reader, &n, &x)
		a := make([]int, n)
		sum := int64(0)
		max := int64(0)
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &a[i])
			sum += int64(a[i])
			if a[i]%x == 0 {
				max += int64(a[i] / x)
			} else {
				max += int64((a[i] / x) + 1)
			}
		}
		min := sum / int64(x)
		if sum%int64(x) != 0 {
			min++
		}
		fmt.Println(min, max)
	}
}

package main

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

var sc = bufio.NewScanner(os.Stdin)
var wr = bufio.NewWriter(os.Stdout)

func main() {
	defer wr.Flush()
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 4096), 1e9)
	// this template is new version.
	// use getI(), getS(), getInts(), getF()
	for i := getI(); i > 0; i-- {
		n, x := getI(), getI()
		var min, max int64
		for i := int64(0); i < n; i++ {
			num := getI()
			min += num
			max += (num + x - 1) / x
		}
		min = (min + x - 1) / x
		printf("%d %d\n", min, max)
	}
}

// !------- HELPERS -------!

func out(x ...interface{}) {
	fmt.Fprintln(wr, x...)
}

func printf(f string, a ...interface{}) {
	fmt.Fprintf(wr, f, a...)
}

func getI() int64 {
	s := getS()
	i := int64(0)
	if s[0] == '-' {
		for _, r := range s[1:] {
			i *= 10
			i -= int64(r - '0')
		}
		return i
	}
	for _, r := range s {
		i *= 10
		i += int64(r - '0')
	}
	return i
}

func getF() float64 {
	sc.Scan()
	i, e := strconv.ParseFloat(sc.Text(), 64)
	if e != nil {
		panic(e)
	}
	return i
}

func getInts(N int64) []int64 {
	ret := make([]int64, N)
	for i := range ret {
		ret[i] = getI()
	}
	return ret
}

func getS() string {
	if !sc.Scan() {
		panic(sc.Err())
	}
	return sc.Text()
}

func nsort(data ...int64) {
	sort.Slice(data, func(i, j int) bool { return data[i] < data[j] })
}

func nsum(data ...int64) int64 {
	var res int64
	for _, n := range data {
		res += n
	}
	return res
}

func njoin(s ...int64) string {
	return strings.Trim(fmt.Sprintf("%v", s), "[]")
}

func forEach(n int64, fn func(int64)) {
	for i := int64(0); i < n; i++ {
		fn(i)
	}
}

// min, max, asub, abs
func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

// min for n entry
func nmin(a ...int64) int64 {
	ret := a[0]
	for _, e := range a {
		ret = min(ret, e)
	}
	return ret
}

// max for n entry
func nmax(a ...int64) int64 {
	ret := a[0]
	for _, e := range a {
		ret = max(ret, e)
	}
	return ret
}

func asub(a, b int64) int64 {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int64) int64 {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int64, x int64) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int64, x int64) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

package main

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

var sc = bufio.NewScanner(os.Stdin)
var wr = bufio.NewWriter(os.Stdout)

func main() {
	defer wr.Flush()
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 4096), 1e9)
	// this template is new version.
	// use getI(), getS(), getInts(), getF()
	for i := getI(); i > 0; i-- {
		n, x := getI(), getI()
		a := getInts(n)
		var min, max int64
		for _, num := range a {
			min += num
			max += (num + x - 1) / x
		}
		min = (min + x - 1) / x
		printf("%d %d\n", min, max)
	}
}

// !------- HELPERS -------!

func out(x ...interface{}) {
	fmt.Fprintln(wr, x...)
}

func printf(f string, a ...interface{}) {
	fmt.Fprintf(wr, f, a...)
}

func getI() int64 {
	s := getS()
	i := int64(0)
	if s[0] == '-' {
		for _, r := range s[1:] {
			i *= 10
			i -= int64(r - '0')
		}
		return i
	}
	for _, r := range s {
		i *= 10
		i += int64(r - '0')
	}
	return i
}

func getF() float64 {
	sc.Scan()
	i, e := strconv.ParseFloat(sc.Text(), 64)
	if e != nil {
		panic(e)
	}
	return i
}

func getInts(N int64) []int64 {
	ret := make([]int64, N)
	for i := range ret {
		ret[i] = getI()
	}
	return ret
}

func getS() string {
	if !sc.Scan() {
		panic(sc.Err())
	}
	return sc.Text()
}

func nsort(data ...int64) {
	sort.Slice(data, func(i, j int) bool { return data[i] < data[j] })
}

func nsum(data ...int64) int64 {
	var res int64
	for _, n := range data {
		res += n
	}
	return res
}

func njoin(s ...int64) string {
	return strings.Trim(fmt.Sprintf("%v", s), "[]")
}

func forEach(n int64, fn func(int64)) {
	for i := int64(0); i < n; i++ {
		fn(i)
	}
}

// min, max, asub, abs
func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

// min for n entry
func nmin(a ...int64) int64 {
	ret := a[0]
	for _, e := range a {
		ret = min(ret, e)
	}
	return ret
}

// max for n entry
func nmax(a ...int64) int64 {
	ret := a[0]
	for _, e := range a {
		ret = max(ret, e)
	}
	return ret
}

func asub(a, b int64) int64 {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int64) int64 {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int64, x int64) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int64, x int64) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

// 1471A. Strange Partition
package main

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

func main() {
	var T int
	reader := bufio.NewReader(os.Stdin)
	fmt.Fscan(reader, &T)
	for t := 1; t <= T; t++ {
		var n, x int
		fmt.Fscan(reader, &n, &x)
		a := make([]int, n)
		sum := int64(0)
		max := 0
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &a[i])
			sum += int64(a[i])
			if a[i]%x == 0 {
				max += a[i] / x
			} else {
				max += (a[i] / x) + 1
			}
		}
		min := sum / int64(x)
		if sum%int64(x) != 0 {
			min++
		}
		fmt.Println(min, max)
	}
}

// 1471A. Strange Partition
package main

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

func main() {
	var T int
	reader := bufio.NewReader(os.Stdin)
	fmt.Fscan(reader, &T)
	for t := 1; t <= T; t++ {
		var n, x int
		fmt.Fscan(reader, &n, &x)
		a := make([]int, n)
		sum := 0
		max := 0
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &a[i])
			sum += a[i]
			if a[i]%x == 0 {
				max += a[i] / x
			} else {
				max += (a[i] / x) + 1
			}
		}
		min := sum / x
		if sum%x != 0 {
			min++
		}
		fmt.Println(min, max)
	}
}

// 1471A. Strange Partition
package main

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

func main() {
	var T int
	reader := bufio.NewReader(os.Stdin)
	fmt.Fscan(reader, &T)
	for t := 1; t <= T; t++ {
		var n, x int
		fmt.Fscan(reader, &n, &x)
		a := make([]int, n)
		sum := 0
		max := 0
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &a[i])
			sum += a[i]
			if a[i]%x == 0 {
				max += a[i] / x
			} else {
				max += (a[i] / x) + 1
			}
		}
		min := sum / x
		fmt.Println(min, max)
	}
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var t int
	fmt.Fscan(in, &t)
	for t > 0 {
		var n, x int
		fmt.Fscan(in, &n, &x)
		mn := 0
		mx := 0
		for i := 0; i < n; i++ {
			var num int
			fmt.Fscan(in, &num)
			mn += num
			mx += (num + x - 1) / x
		}
		mn = (mn + x - 1) / x
		fmt.Println(mn, mx)
		t--
	}

}

package main
import (
"bufio"
"fmt"
"io"
"os"
)

func FUG(n, x int64) int64{
H := (n - (n%x))/x
return H
}

func main() {

var input io.Reader = bufio.NewReader(os.Stdin)
var t int
fmt.Fscan(input, &t)

for o:=0;o<t;o++{
var n, x int
fmt.Fscan(input, &n)
fmt.Fscan(input, &x)

ARRAY := make([]int, n)
for i:=0; i<n;i++{
fmt.Fscan(input, &ARRAY[i])
}
var SUM int64
for m :=0; m< n; m++{
SUM = SUM + int64(ARRAY[m])
}

var MIN int64
var MAX int64

MIN = FUG(SUM, int64(x))
for k :=0; k< n;k++{
MAX = MAX + FUG(int64(ARRAY[k]), int64(x))
}
fmt.Print(MIN, " ")
fmt.Print(MAX, " ")
fmt.Println()
}
}

package main

import (

"bufio"

"fmt"

"io"

"os"

)

func FUG(n, x int64) int64{
H := (n - (n%x))/x

return H
}

func main() {

var input io.Reader = bufio.NewReader(os.Stdin)

var t int

fmt.Fscan(input, &t)

for o:=0;o<t;o++{

var n, x int

fmt.Fscan(input, &n)

fmt.Fscan(input, &x)

ARRAY := make([]int, n)

for i:=0; i<n;i++{

fmt.Fscan(input, &ARRAY[i])}

var SUM int64

for m :=0; m< n; m++{

SUM = SUM + int64(ARRAY[m])
}

var MIN int64
var MAX int64

MIN = FUG(SUM, int64(x))
for k :=0; k< n;k++{
MAX = MAX + FUG(int64(ARRAY[k]), int64(x))
}
fmt.Print(MIN, " ")
fmt.Print(MAX, " ")
fmt.Println()
}
}

package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"os"
	"strings"
)

var bytes []byte

func nextByte() byte {
	b := bytes[0]
	bytes = bytes[1:]
	return b
}

func ScanInt64() int64 {
	var negative bool
	var result int64

	b := nextByte()

	for ; b < '0' || b > '9'; b = nextByte() {
		if b == '-' {
			negative = true
		}
	}

	for ; '0' <= b && b <= '9'; b = nextByte() {
		result = (result << 3) + (result << 1) + int64(b-'0')
	}

	if negative {
		return -result
	} else {
		return result
	}
}

func ScanInt() int {
	return int(ScanInt64())
}

func ScanString() string {
	builder := strings.Builder{}

	for b := nextByte(); b != '\r'; b = nextByte() {
		if b != '\n' {
			builder.WriteByte(b)
		}
	}

	return builder.String()
}

func init() {
	f, err := os.Open("in.txt")

	if err == nil {
		defer f.Close()
	} else {
		f = os.Stdin
	}

	bytes, _ = ioutil.ReadAll(bufio.NewReader(f))
}

func main() {
	for t := ScanInt(); t > 0; t-- {
		n, x := ScanInt(), ScanInt()
		min, max, sum := 0, 0, 0

		for i := 0; i < n; i++ {
			a := ScanInt()

			sum += a

			max += a / x
			if a%x > 0 {
				max++
			}
		}

		min = sum / x
		if sum%x > 0 {
			min++
		}

		fmt.Println(min, max)
	}
}

package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"os"
	"strings"
)

var bytes []byte

func nextByte() byte {
	b := bytes[0]
	bytes = bytes[1:]
	return b
}

func scanInt64() int64 {
	var negative bool
	var result int64

	b := nextByte()

	for ; b < '0' || b > '9'; b = nextByte() {
		if b == '-' {
			negative = true
		}
	}

	for ; '0' <= b && b <= '9'; b = nextByte() {
		result = (result << 3) + (result << 1) + int64(b-'0')
	}

	if negative {
		return -result
	} else {
		return result
	}
}

func scanInt() int {
	return int(scanInt64())
}

func ScanString() string {
	builder := strings.Builder{}

	for b := nextByte(); b != '\r'; b = nextByte() {
		if b != '\n' {
			builder.WriteByte(b)
		}
	}

	return builder.String()
}

func init() {
	f, err := os.Open("in.txt")

	if err == nil {
		defer f.Close()
	} else {
		f = os.Stdin
	}

	bytes, _ = ioutil.ReadAll(bufio.NewReader(f))
}

func main() {
	for t := scanInt(); t > 0; t-- {
		n, k := scanInt(), scanInt()

		if n%k == 0 {
			fmt.Println(1)
		} else {
			diff := k - n%k

			if diff%n == 0 {
				fmt.Println(1 + diff/n)
			} else {
				fmt.Println(2 + diff/n)
			}
		}
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
)
var (
    input = bufio.NewReader(os.Stdin)
    output = bufio.NewWriter(os.Stdout)
)

func assert(test bool) {
    if !test {panic("assertion!")}
}

// (c) Dmitriy Blokhin (sv.dblokhin@gmail.com)
func main() {
    var t int
	fmt.Fscan(input, &t)
    for t > 0 {
        t--
        solve()
    }
    output.Flush()
}

func solve() {
    var n, x int64
    fmt.Fscan(input, &n, &x)
    a := make([]int64, n)
    sum, ma := int64(0), int64(0)
    for i := 0; i < len(a); i++ {
        fmt.Fscan(input, &a[i])
        ma += (a[i] - 1) / n + 1
        sum += a[i]
    }

    fmt.Fprintln(output, (sum - 1) / n + 1, ma)
}

func min(a, b int) int {
    if a < b { return a}
    return b
}

// https://codeforces.com/contest/1472/problem/E

package main

import (
	"bufio"
	"fmt"
	"os"
)
var (
    input = bufio.NewReader(os.Stdin)
    output = bufio.NewWriter(os.Stdout)
)

func assert(test bool) {
    if !test {panic("assertion!")}
}

// (c) Dmitriy Blokhin (sv.dblokhin@gmail.com)
func main() {
    var t int
	fmt.Fscan(input, &t)
    for t > 0 {
        t--
        solve()
    }
    output.Flush()
}

func solve() {
    var n, x int
    fmt.Fscan(input, &n, &x)
    a := make([]int, n)
    sum, ma := 0, 0
    for i := 0; i < len(a); i++ {
        fmt.Fscan(input, &a[i])
        ma += (a[i] - 1) / n + 1
        sum += a[i]
    }

    fmt.Fprintln(output, (sum - 1) / n + 1, ma)
}

func min(a, b int) int {
    if a < b { return a}
    return b
}

package main

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

var (
	in  = bufio.NewReader(os.Stdin)
	out = bufio.NewWriter(os.Stdout)
	t   int
	n   int
	x   float64
)

func main() {

	defer out.Flush()

	fmt.Fscan(in, &t)

	for ; t > 0; t-- {

		fmt.Fscan(in, &n, &x)
		a := make([]float64, n)

		sum := float64(0)
		for i := range a {
			fmt.Fscan(in, &a[i])
			sum += a[i]
		}

		solve(a, n, x, sum)

	}

}

func solve(a []float64, n int, x float64, sum float64) {

	min := math.Ceil(sum / x)
	max := float64(0)

	for i := range a {
		max += math.Ceil(a[i] / x)
	}

	fmt.Fprintln(out, min, max)

}

//取絕對值
func abs(n int) int {
	if n >= 0 {
		return n
	} else {
		return -n
	}
}

//印出數字陣列
func printArr(array []int) {

	for i := range array {
		fmt.Printf("%d ", array[i])
	}

	fmt.Println()

}

package main

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

func ceil(a, b int) int {
	if a%b == 0 {
		return a / b
	}
	return a/b + 1
}

func main() {
	in := bufio.NewReader(os.Stdin)

	var t, n, x, a int
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		fmt.Fscan(in, &n, &x)
		minSum := 0
		maxSum := 0
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &a)
			minSum += a
			maxSum += ceil(a, x)
		}

		fmt.Println(ceil(minSum, x), maxSum)
	}
}


package main

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

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }

func getLine() string {
	s, _ := reader.ReadString('\n')
	if strings.HasSuffix(s, "\r\n") {
		s = s[:len(s)-2]
	} else if strings.HasSuffix(s, "\n") {
		s = s[:len(s)-1]
	}
	return s
}
func getLine2Int() (n int) {
	scanf("%d\n", &n)
	return
}
func getLine2Int2() (a, b int) {
	scanf("%d %d\n", &a, &b)
	return
}
func getLine2Ints(n int) []int64 {
	ans := make([]int64, n)
	for i := 0; i < n; i++ {
		scanf("%d ", &ans[i])
	}
	scanf("%d\n", &ans[n-1])
	return ans
}

func pcheck(i bool) {
	if i {
		printf("Yes\n")
	} else {
		printf("No\n")
	}
}

var debug = true

func see(a interface{}) {
	if debug {
		printf("DEBUG:%v\n", a)
	}
}

func main() {
	defer writer.Flush()

	n := getLine2Int()
	if n == 1 {
		printf("-1\n")
	} else {
		printf("%d %d %d\n", n, n+1, n*n+n)
	}
}

package main

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

func solve1() {
    _, a, b := readInt(), readInt()-1, readInt()-1
    s := readString()
    ans := 0
    if s[a] != s[b] {
        cur := abs(a-b)
        for i := range s {
            if s[i] != s[b] {
                cur = min(cur, abs(i-b))
            } else {
                cur = min(cur, abs(i-a))
            }
        }
        ans = cur
    }
    fmt.Println(ans)
}

func solve() {
    const mx = 1000
    n := readInt()
    if n == 1 {
        fmt.Println(-1)
    } else {
        fmt.Println(n, n*n+n,n+1)
    }
}

// Helpers

var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)

func main() {
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

// Math

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

// IO

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}

func readIntArray(sz int) []int {
	a := make([]int, sz)
	for i := 0; i < sz; i++ {
		a[i] = readInt()
	}
	return a
}

func readInt64Array(n int) []int64 {
	res := make([]int64, n)
	for i := 0; i < n; i++ {
		res[i] = readInt64()
	}
	return res
}

// Sort

type Ints64 []int64

func (a Ints64) Len() int           { return len(a) }
func (a Ints64) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a Ints64) Less(i, j int) bool { return a[i] < a[j] }

/* Sort tempalte
func (a ) Len() int           { return len(a) }
func (a ) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ) Less(i, j int) bool { return  }
*/

/*
URL:
https://codeforces.com/problemset/problem/743/C
*/

package main

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
)

/********** FAU standard libraries **********/

//fmt.Sprintf("%b\n", 255) 	// binary expression

/********** I/O usage **********/

//str := ReadString()
//i := ReadInt()
//X := ReadIntSlice(n)
//S := ReadRuneSlice()
//a := ReadFloat64()
//A := ReadFloat64Slice(n)

//str := ZeroPaddingRuneSlice(num, 32)
//str := PrintIntsLine(X...)

/*******************************************************************/

const (
	// General purpose
	MOD          = 1000000000 + 7
	ALPHABET_NUM = 26
	INF_INT64    = math.MaxInt64
	INF_BIT60    = 1 << 60
	INF_INT32    = math.MaxInt32
	INF_BIT30    = 1 << 30
	NIL          = -1

	// for dijkstra, prim, and so on
	WHITE = 0
	GRAY  = 1
	BLACK = 2
)

func init() {
	// bufio.ScanWords <---> bufio.ScanLines
	ReadString = newReadString(os.Stdin, bufio.ScanWords)
	stdout = bufio.NewWriter(os.Stdout)
}

var (
	n int
)

func main() {
	n = ReadInt()

	if n == 1 {
		fmt.Println(-1)
		return
	}

	fmt.Println(n, n+1, n*(n+1))
}

/*******************************************************************/

/*********** I/O ***********/

var (
	// ReadString returns a WORD string.
	ReadString func() string
	stdout     *bufio.Writer
)

func newReadString(ior io.Reader, sf bufio.SplitFunc) func() string {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+9)) // for Codeforces
	r.Split(sf)

	return func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
}

// ReadInt returns an integer.
func ReadInt() int {
	return int(readInt64())
}
func ReadInt2() (int, int) {
	return int(readInt64()), int(readInt64())
}
func ReadInt3() (int, int, int) {
	return int(readInt64()), int(readInt64()), int(readInt64())
}
func ReadInt4() (int, int, int, int) {
	return int(readInt64()), int(readInt64()), int(readInt64()), int(readInt64())
}

// ReadInt64 returns as integer as int64.
func ReadInt64() int64 {
	return readInt64()
}
func ReadInt64_2() (int64, int64) {
	return readInt64(), readInt64()
}
func ReadInt64_3() (int64, int64, int64) {
	return readInt64(), readInt64(), readInt64()
}
func ReadInt64_4() (int64, int64, int64, int64) {
	return readInt64(), readInt64(), readInt64(), readInt64()
}

func readInt64() int64 {
	i, err := strconv.ParseInt(ReadString(), 0, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

// ReadIntSlice returns an integer slice that has n integers.
func ReadIntSlice(n int) []int {
	b := make([]int, n)
	for i := 0; i < n; i++ {
		b[i] = ReadInt()
	}
	return b
}

// ReadInt64Slice returns as int64 slice that has n integers.
func ReadInt64Slice(n int) []int64 {
	b := make([]int64, n)
	for i := 0; i < n; i++ {
		b[i] = ReadInt64()
	}
	return b
}

// ReadFloat64 returns an float64.
func ReadFloat64() float64 {
	return float64(readFloat64())
}

func readFloat64() float64 {
	f, err := strconv.ParseFloat(ReadString(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

// ReadFloatSlice returns an float64 slice that has n float64.
func ReadFloat64Slice(n int) []float64 {
	b := make([]float64, n)
	for i := 0; i < n; i++ {
		b[i] = ReadFloat64()
	}
	return b
}

// ReadRuneSlice returns a rune slice.
func ReadRuneSlice() []rune {
	return []rune(ReadString())
}

/*********** Debugging ***********/

// ZeroPaddingRuneSlice returns binary expressions of integer n with zero padding.
// For debugging use.
func ZeroPaddingRuneSlice(n, digitsNum int) []rune {
	sn := fmt.Sprintf("%b", n)

	residualLength := digitsNum - len(sn)
	if residualLength <= 0 {
		return []rune(sn)
	}

	zeros := make([]rune, residualLength)
	for i := 0; i < len(zeros); i++ {
		zeros[i] = '0'
	}

	res := []rune{}
	res = append(res, zeros...)
	res = append(res, []rune(sn)...)

	return res
}

// Strtoi is a wrapper of strconv.Atoi().
// If strconv.Atoi() returns an error, Strtoi calls panic.
func Strtoi(s string) int {
	if i, err := strconv.Atoi(s); err != nil {
		panic(errors.New("[argument error]: Strtoi only accepts integer string"))
	} else {
		return i
	}
}

// PrintIntsLine returns integers string delimited by a space.
func PrintIntsLine(A ...int) string {
	res := []rune{}

	for i := 0; i < len(A); i++ {
		str := strconv.Itoa(A[i])
		res = append(res, []rune(str)...)

		if i != len(A)-1 {
			res = append(res, ' ')
		}
	}

	return string(res)
}

// PrintIntsLine returns integers string delimited by a space.
func PrintInts64Line(A ...int64) string {
	res := []rune{}

	for i := 0; i < len(A); i++ {
		str := strconv.FormatInt(A[i], 10) // 64bit int version
		res = append(res, []rune(str)...)

		if i != len(A)-1 {
			res = append(res, ' ')
		}
	}

	return string(res)
}

// PrintfDebug is wrapper of fmt.Fprintf(os.Stderr, format, a...)
func PrintfDebug(format string, a ...interface{}) {
	fmt.Fprintf(os.Stderr, format, a...)
}

// PrintfBufStdout is function for output strings to buffered os.Stdout.
// You may have to call stdout.Flush() finally.
func PrintfBufStdout(format string, a ...interface{}) {
	fmt.Fprintf(stdout, format, a...)
}

// Codeforces 743 C Complete the Word
// int - 32 bit type !!!!
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"strconv"
)
var in *bufio.Reader

func readFive() (int,int,int,int,int) {
    var a [5]int
	s, err := in.ReadString('\n')
	if err != nil {
		fmt.Println("first read failure", err)
		panic(err)
	}
	ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for i:=0; i<len(ss); i++ {
        a[i], err = strconv.Atoi(ss[i])
        if err != nil {
            fmt.Println("n atoi failure", err)
            panic(err)
        }
    }
    return a[0],a[1],a[2],a[3],a[4]
}

func readLineNumbs(n int) []int {
    a := make([]int, n)
    s, err := in.ReadString('\n')
    if err != nil {
        fmt.Println("read failure", err)
        panic(err)
    }
    ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for j:=0; j<n; j++ {
        aa,err := strconv.Atoi(ss[j])
        if err != nil {
            fmt.Println("aa conv failed", err)
            panic(err)
        }
        a[j] = aa
    }
    return a
}

var n int
var x, y, z int

func readData() {
 	in = bufio.NewReader(os.Stdin)
	// reading s
    n,_,_,_,_ = readFive()
}

func solve() {
    x = n
    y = n+1
    z = x*y
}

func printRes() {
	if y==z {
		fmt.Println(-1)
	} else {
		fmt.Printf("%d %d %d\n", x,y,z)
	}
}

func main() {
 	readData()
    solve()
    printRes()
}

package main

import "fmt"
func main() {
	var n int
	fmt.Scan(&n)
	if n == 1 {
		fmt.Println("-1")
		return
	}
	for i := n + 1; i < 2 * n; i++ {
		if (n * i) % (i - n) == 0 {
			fmt.Println(n * i / (i - n), n, i)
			return
		}
	}
}

package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"os"
)

type Node struct {
	a, b int
}

func main() {
	b, _ := ioutil.ReadAll(os.Stdin)
	r := bytes.NewReader(b)

	var n int

	fmt.Fscanf(r, "%d\n", &n)
	ans := make([]Node, n+1)

	cnt := 0

	for i := 1; i <= n; i++ {

		tmp := 2*i - n
		if tmp > 0 && (n*i)%tmp == 0 {
			cnt++
			ans[cnt].a = i
			ans[cnt].b = n * i / tmp
		}
	}

	var x, y int

	z := -1

	for i := 1; i <= cnt; i++ {
		//fmt.Printf("%d %d\n", ans[i].a, ans[i].b)

		x, y = ans[i].a, ans[i].b

		if x != 1 && y != x+1 && y != x*(x+1) {
			z = x * (x + 1)
			x = x + 1
			break

		}

		if y != 1 && x != y+1 && x != y*(y+1) {
			z = y * (y + 1)
			y = y + 1
			break
		}
	}

	if z != -1 {
		fmt.Printf("%d %d %d\n", x, y, z)
	} else {
		fmt.Printf("-1\n")
	}

}

// Codeforces 743 C Complete the Word
// int - 32 bit type !!!!
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"strconv"
)
var in *bufio.Reader

func readFive() (int,int,int,int,int) {
    var a [5]int
	s, err := in.ReadString('\n')
	if err != nil {
		fmt.Println("first read failure", err)
		panic(err)
	}
	ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for i:=0; i<len(ss); i++ {
        a[i], err = strconv.Atoi(ss[i])
        if err != nil {
            fmt.Println("n atoi failure", err)
            panic(err)
        }
    }
    return a[0],a[1],a[2],a[3],a[4]
}

func readLineNumbs(n int) []int {
    a := make([]int, n)
    s, err := in.ReadString('\n')
    if err != nil {
        fmt.Println("read failure", err)
        panic(err)
    }
    ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for j:=0; j<n; j++ {
        aa,err := strconv.Atoi(ss[j])
        if err != nil {
            fmt.Println("aa conv failed", err)
            panic(err)
        }
        a[j] = aa
    }
    return a
}

var n int
var x, y, z int

func readData() {
 	in = bufio.NewReader(os.Stdin)
	// reading s
    n,_,_,_,_ = readFive()
}

func solve() {
    x = n
    y = n+1
    z = x*y
}

func printRes() {
    fmt.Printf("%d %d %d\n", x,y,z)
}

func main() {
 	readData()
    solve()
    printRes()
}

package main

import "fmt"
func main() {
	var n int
	fmt.Scan(&n)
	fmt.Println(n, 2 * n, 2 * n)
}