```go
package main

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

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

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

func (fs *FastScanner) NextInt64() int64 {
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c != ' ' && c != '\n' && c != '\r' && c != '\t' {
			break
		}
		fs.idx++
	}
	sign := int64(1)
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var val int64
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int64(c-'0')
		fs.idx++
	}
	return sign * val
}

func writeInt64(w *bufio.Writer, x int64) {
	if x == 0 {
		w.WriteByte('0')
		return
	}
	if x < 0 {
		w.WriteByte('-')
		x = -x
	}
	var buf [20]byte
	i := len(buf)
	for x > 0 {
		i--
		buf[i] = byte('0' + x%10)
		x /= 10
	}
	w.Write(buf[i:])
}

func main() {
	fs := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	t := int(fs.NextInt64())
	for ; t > 0; t-- {
		n := int(fs.NextInt64())
		pos := make([]int64, 0, n)
		neg := make([]int64, 0, n)
		zeros := 0

		for i := 0; i < n; i++ {
			x := fs.NextInt64()
			if x > 0 {
				pos = append(pos, x)
			} else if x < 0 {
				neg = append(neg, x)
			} else {
				zeros++
			}
		}

		if len(pos) == 0 && len(neg) == 0 {
			out.WriteString("No\n")
			continue
		}

		out.WriteString("Yes\n")

		ans := make([]int64, 0, n)
		var s int64
		i, j := 0, 0

		for i < len(pos) || j < len(neg) {
			if s <= 0 {
				x := pos[i]
				i++
				ans = append(ans, x)
				s += x
			} else {
				x := neg[j]
				j++
				ans = append(ans, x)
				s += x
			}
		}

		for k := 0; k < zeros; k++ {
			ans = append(ans, 0)
		}

		for idx, x := range ans {
			if idx > 0 {
				out.WriteByte(' ')
			}
			writeInt64(out, x)
		}
		out.WriteByte('\n')
	}
}
```