Polycarp has three sisters: Alice, Barbara, and Cerene. They're collecting coins. Currently, Alice has $$$a$$$ coins, Barbara has $$$b$$$ coins and Cerene has $$$c$$$ coins. Recently Polycarp has returned from the trip around the world and brought $$$n$$$ coins.He wants to distribute all these $$$n$$$ coins between his sisters in such a way that the number of coins Alice has is equal to the number of coins Barbara has and is equal to the number of coins Cerene has. In other words, if Polycarp gives $$$A$$$ coins to Alice, $$$B$$$ coins to Barbara and $$$C$$$ coins to Cerene ($$$A+B+C=n$$$), then $$$a + A = b + B = c + C$$$.Note that A, B or C (the number of coins Polycarp gives to Alice, Barbara and Cerene correspondingly) can be 0.Your task is to find out if it is possible to distribute all $$$n$$$ coins between sisters in a way described above.You have to answer $$$t$$$ independent test cases.

The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$t$$$ lines describe test cases. Each test case is given on a new line and consists of four space-separated integers $$$a, b, c$$$ and $$$n$$$ ($$$1 \le a, b, c, n \le 10^8$$$) — the number of coins Alice has, the number of coins Barbara has, the number of coins Cerene has and the number of coins Polycarp has.

For each test case, print "YES" if Polycarp can distribute all $$$n$$$ coins between his sisters and "NO" otherwise.

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"
	"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 (
	"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 "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)%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"))

}


You have integer $$$n$$$. Calculate how many ways are there to fully cover belt-like area of $$$4n-2$$$ triangles with diamond shapes. Diamond shape consists of two triangles. You can move, rotate or flip the shape, but you cannot scale it. $$$2$$$ coverings are different if some $$$2$$$ triangles are covered by the same diamond shape in one of them and by different diamond shapes in the other one.Please look at pictures below for better understanding.  On the left you can see the diamond shape you will use, and on the right you can see the area you want to fill. These are the figures of the area you want to fill for $$$n = 1, 2, 3, 4$$$. You have to answer $$$t$$$ independent test cases.

The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^{4}$$$) — the number of test cases. Each of the next $$$t$$$ lines contains a single integer $$$n$$$ ($$$1 \le n \le 10^{9}$$$).

For each test case, print the number of ways to fully cover belt-like area of $$$4n-2$$$ triangles using diamond shape. It can be shown that under given constraints this number of ways doesn't exceed $$$10^{18}$$$.

NoteIn the first test case, there are the following $$$2$$$ ways to fill the area:  In the second test case, there is a unique way to fill the area:

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 (
	"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 (
	"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")
		}
	}
}


You are given an array $$$a$$$ of length $$$n$$$, and an integer $$$x$$$. You can perform the following operation as many times as you would like (possibly zero): replace two adjacent elements of the array by their sum. For example, if the initial array was $$$[3, 6, 9]$$$, in a single operation one can replace the last two elements by their sum, yielding an array $$$[3, 15]$$$, or replace the first two elements to get an array $$$[9, 9]$$$. Note that the size of the array decreases after each operation.The beauty of an array $$$b=[b_1, \ldots, b_k]$$$ is defined as $$$\sum_{i=1}^k \left\lceil \frac{b_i}{x} \right\rceil$$$, which means that we divide each element by $$$x$$$, round it up to the nearest integer, and sum up the resulting values. For example, if $$$x = 3$$$, and the array is $$$[4, 11, 6]$$$, the beauty of the array is equal to $$$\left\lceil \frac{4}{3} \right\rceil + \left\lceil \frac{11}{3} \right\rceil + \left\lceil \frac{6}{3} \right\rceil = 2 + 4 + 2 = 8$$$.Please determine the minimum and the maximum beauty you can get by performing some operations on the original array.

The first input line contains a single integer $$$t$$$ — the number of test cases ($$$1 \le t \le 1000$$$). The first line of each test case contains two integers $$$n$$$ and $$$x$$$ ($$$1 \leq n \leq 10^5$$$, $$$1 \leq x \leq 10^9$$$). The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \leq a_i \leq 10^9$$$), the elements of the array $$$a$$$.  It is guaranteed that the sum of values of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

For each test case output two integers — the minimal and the maximal possible beauty.

NoteIn the first test case the beauty of the array does not change if we perform any operations.In the second example we can leave the array unchanged to attain the maximum beauty, and to get the minimum beauty one can replace two elements $$$4$$$ and $$$11$$$ with their sum, yielding an array $$$[6, 15]$$$, which has its beauty equal to $$$7$$$.

// 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
}

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"
	"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"
"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 := 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)
	}
}


Vladik and Chloe decided to determine who of them is better at math. Vladik claimed that for any positive integer n he can represent fraction  as a sum of three distinct positive fractions in form .Help Vladik with that, i.e for a given n find three distinct positive integers x, y and z such that . Because Chloe can't check Vladik's answer if the numbers are large, he asks you to print numbers not exceeding 109.If there is no such answer, print -1.

The single line contains single integer n (1 ≤ n ≤ 104).

If the answer exists, print 3 distinct numbers x, y and z (1 ≤ x, y, z ≤ 109, x ≠ y, x ≠ z, y ≠ z). Otherwise print -1. If there are multiple answers, print any of them.

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  }
*/

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)
	}
}

/*
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)
}