You have a deck of $n$ cards, and you'd like to reorder it to a new one.

Each card has a value between $1$ and $n$ equal to $p_i$. All $p_i$ are pairwise distinct. Cards in a deck are numbered from bottom to top, i. e. $p_1$ stands for the bottom card, $p_n$ is the top card.

In each step you pick some integer $k > 0$, take the top $k$ cards from the original deck and place them, in the order they are now, on top of the new deck. You perform this operation until the original deck is empty. (Refer to the notes section for the better understanding.)

Let's define an order of a deck as $\sum\limits_{i = 1}^{n}{n^{n - i} \cdot p_i}$.

Given the original deck, output the deck with maximum possible order you can make using the operation above.


-----Input-----

The first line contains a single integer $t$ ($1 \le t \le 1000$) — the number of test cases.

The first line of each test case contains the single integer $n$ ($1 \le n \le 10^5$) — the size of deck you have.

The second line contains $n$ integers $p_1, p_2,\dots, p_n$ ($1 \le p_i \le n$; $p_i \neq p_j$ if $i \neq j$) — values of card in the deck from bottom to top.

It's guaranteed that the sum of $n$ over all test cases doesn't exceed $10^5$.


-----Output-----

For each test case print the deck with maximum possible order. Print values of cards in the deck from bottom to top.

If there are multiple answers, print any of them.


-----Examples-----

Input
4
4
1 2 3 4
5
1 5 2 4 3
6
4 2 5 3 6 1
1
1
Output
4 3 2 1
5 2 4 3 1
6 1 5 3 4 2
1


-----Note-----

In the first test case, one of the optimal strategies is the next one:

take $1$ card from the top of $p$ and move it to $p'$: $p$ becomes $[1, 2, 3]$, $p'$ becomes $[4]$;

take $1$ card from the top of $p$: $p$ becomes $[1, 2]$, $p'$ becomes $[4, 3]$;

take $1$ card from the top of $p$: $p$ becomes $[1]$, $p'$ becomes $[4, 3, 2]$;

take $1$ card from the top of $p$: $p$ becomes empty, $p'$ becomes $[4, 3, 2, 1]$.

In result, $p'$ has order equal to $4^3 \cdot 4 + 4^2 \cdot 3 + 4^1 \cdot 2 + 4^0 \cdot 1$ $=$ $256 + 48 + 8 + 1 = 313$.

In the second test case, one of the optimal strategies is:

take $4$ cards from the top of $p$ and move it to $p'$: $p$ becomes $[1]$, $p'$ becomes $[5, 2, 4, 3]$;

take $1$ card from the top of $p$ and move it to $p'$: $p$ becomes empty, $p'$ becomes $[5, 2, 4, 3, 1]$;

In result, $p'$ has order equal to $5^4 \cdot 5 + 5^3 \cdot 2 + 5^2 \cdot 4 + 5^1 \cdot 3 + 5^0 \cdot 1$ $=$ $3125 + 250 + 100 + 15 + 1 = 3491$.

In the third test case, one of the optimal strategies is:

take $2$ cards from the top of $p$ and move it to $p'$: $p$ becomes $[4, 2, 5, 3]$, $p'$ becomes $[6, 1]$;

take $2$ cards from the top of $p$ and move it to $p'$: $p$ becomes $[4, 2]$, $p'$ becomes $[6, 1, 5, 3]$;

take $2$ cards from the top of $p$ and move it to $p'$: $p$ becomes empty, $p'$ becomes $[6, 1, 5, 3, 4, 2]$.

In result, $p'$ has order equal to $6^5 \cdot 6 + 6^4 \cdot 1 + 6^3 \cdot 5 + 6^2 \cdot 3 + 6^1 \cdot 4 + 6^0 \cdot 2$ $=$ $46656 + 1296 + 1080 + 108 + 24 + 2 = 49166$.

Source: codeforces | Difficulty: EASY
Tags: Data structures

Mathematics

Greedy algorithms


Solutions:
import heapq
from math import sqrt
import operator
import sys
inf_var = 0
if inf_var == 1:
	inf = open('input.txt', 'r')
else:
	inf = sys.stdin
input = inf.readline

def read_one_int():
	return int(input().rstrip('\n'))

def read_list_of_ints():
	res = [int(val) for val in input().rstrip('\n').split(' ')]
	return res

def read_str():
	return input().rstrip()

def check_seq(deck_size, deck_cards):
	new_deck = []
	used = [0 for i in range(deck_size)]
	last_used_index = deck_size - 1
	prev_ind = deck_size
	for i in range(deck_size - 1, -1, -1):
		if deck_cards[i] == last_used_index + 1:
			new_deck += deck_cards[i:prev_ind]
			for j in range(i, prev_ind):
				used[deck_cards[j] - 1] = 1
			prev_ind = i
			j = -1
			while True:
				cur_ind = j + last_used_index
				if cur_ind < 0:
					last_used_index = -1
					break
				if used[cur_ind]:
					j -= 1
					continue
				else:
					last_used_index = cur_ind
					break
	return ' '.join(map(str, new_deck))

def main():
	cnt = read_one_int()
	for _ in range(cnt):
		deck_size = read_one_int()
		deck_cards = read_list_of_ints()
		res = check_seq(deck_size, deck_cards)
		print(res)
main()


t = int(input())
for _ in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	ans = []
	p1 = [-1] * (n + 1)
	for i in range(n):
		p1[p[i]] = i
	i = n
	while i:
		while i > 0 and p1[i] == -1:
			i -= 1
		else:
			if i:
				k = 0
				for j in range(p1[i], n):
					ans.append(p[j])
					p1[p[j]] = -1
					k += 1
				n -= k
				i -= 1
			else:
				break
	print(*ans)


import sys

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_list_string():
	return list(map(str, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()

def get_int():
	return int(sys.stdin.readline().strip())

def get_print_int(x):
	sys.stdout.write(str(x) + '\n')

def get_print(x):
	sys.stdout.write(x + '\n')

def get_print_int_same(x):
	sys.stdout.write(str(x) + ' ')

def get_print_same(x):
	sys.stdout.write(x + ' ')
from sys import maxsize

def solve():
	for _ in range(get_int()):
		n = get_int()
		arr = get_list()
		i = n - 1
		j = n - 1
		temp = sorted(arr)
		vis = [False] * n
		ans = []
		while j >= 0:
			t = j
			tt = []
			while t >= 0 and arr[t] != temp[i]:
				vis[arr[t] - 1] = True
				tt.append(arr[t])
				t -= 1
			vis[arr[t] - 1] = True
			tt.append(arr[t])
			tt = tt[::-1]
			for k in tt:
				ans.append(k)
			j = t - 1
			while i >= 0 and vis[i]:
				i -= 1
		get_print(' '.join(map(str, ans)))
solve()


from heapq import heappop, heappush
import sys

class MinMaxSet:

	def __init__(self):
		self.min_queue = []
		self.max_queue = []
		self.entries = {}

	def __len__(self):
		return len(self.entries)

	def add(self, val):
		if val not in self.entries:
			entry_min = [val, False]
			entry_max = [-val, False]
			heappush(self.min_queue, entry_min)
			heappush(self.max_queue, entry_max)
			self.entries[val] = (entry_min, entry_max)

	def delete(self, val):
		if val in self.entries:
			(entry_min, entry_max) = self.entries.pop(val)
			entry_min[-1] = entry_max[-1] = True

	def get_min(self):
		while self.min_queue[0][-1]:
			heappop(self.min_queue)
		return self.min_queue[0][0]

	def get_max(self):
		while self.max_queue[0][-1]:
			heappop(self.max_queue)
		return -self.max_queue[0][0]
t = int(input())
while t > 0:
	n = int(sys.stdin.readline())
	a = list(map(int, sys.stdin.readline().split()))
	used = [0] * n
	pos = [0] * (n + 1)
	ans = list()
	s = MinMaxSet()
	for i in range(n):
		s.add(a[i])
		pos[a[i]] = i
	while len(s) > 0:
		x = s.get_max()
		for j in range(pos[x], n):
			if used[j] > 0:
				break
			used[j] = 1
			s.delete(a[j])
			ans.append(a[j])
	print(*ans)
	t -= 1


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	w = list(map(int, input().split()))
	d = [0] * (n + 1)
	for (i, j) in enumerate(w):
		d[j] = i
	(a, x) = ([], n)
	for i in range(n, 0, -1):
		if d[i] < x:
			a.extend(w[d[i]:x])
			x = d[i]
	print(' '.join(map(str, a)))


def argmax(a):
	m = 0
	res = []
	for j in range(len(a)):
		if a[j] > m:
			m = a[j]
			res.append(j)
	res.reverse()
	return res

def find():
	end = int(input())
	mas = list(map(int, input().split()))
	for j in argmax(mas):
		for k in range(j, end):
			print(mas[k], end=' ')
		end = j
	print()
for i in range(int(input())):
	find()


t = int(input())
for i in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	p_ord = p.copy()
	p_ord.sort()
	k = n - 1
	r = list()
	for j in range(n - 1, -1, -1):
		while p_ord[k] == 0:
			k -= 1
		maximo = p_ord[k]
		p_ord[p[j] - 1] = 0
		if p[j] == maximo:
			r.extend(p[j:])
			del p[j:]
	print(' '.join(map(str, r)))


A = []

def test_case():
	n = int(input())
	a = [int(i) for i in input().split()]
	mp = dict()
	for i in range(n):
		mp[a[i]] = i
	(ans, last) = ([], n)
	for i in range(n, 0, -1):
		if mp[i] <= last:
			ans.extend(a[mp[i]:last])
			last = mp[i]
	A.append(ans)
for _ in range(int(input())):
	test_case()
for a in A:
	print(*a)


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	ar = [int(op) for op in input().split()]
	ans = []
	y = [0 for i in range(n)]
	mx = n
	nmx = n
	ops = n
	while not nmx == 0:
		for i in reversed(range(ops)):
			if y[i] == 0:
				mx = i + 1
				y[i] = 1
				ops = i
				break
		for i in reversed(range(nmx)):
			if mx == ar[i]:
				idx = i
				break
			else:
				y[ar[i] - 1] = 1
		for i in range(nmx - idx):
			ans.append(str(ar[i + idx]))
		nmx = idx
	print(' '.join(ans))


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	look = [0] * n
	maxx = arr[0]
	for i in range(n):
		maxx = max(arr[i], maxx)
		look[i] = maxx
	j = n
	ans = []
	for i in range(n - 1, -1, -1):
		if look[i] == arr[i]:
			ans.append(arr[i:j])
			j = i
	for i in ans:
		print(*i, end=' ')
	print()


N = int(input())
for _ in range(N):
	out = []
	n = int(input())
	l = [int(e) for e in input().split()]
	i = 0
	for j in range(i, n):
		if l[j] > l[i]:
			out += l[i:j][::-1]
			i = j
	out += l[i:n][::-1]
	print(' '.join([str(e) for e in out[::-1]]))


from collections import OrderedDict
import heapq as hq

def show(l):
	for i in l:
		print(i, end=' ')
for _ in range(int(input())):
	n = int(input())
	r = []
	l = list(map(int, input().split()))
	t = [(j, i) for (i, j) in enumerate(l)]
	t.sort(reverse=True)
	od = OrderedDict(t)
	idx = n
	for e in l[::-1]:
		m = next(iter(od))
		if e == m:
			show(l[od[e]:idx])
			idx = od[e]
		del od[e]
	print()


import math
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = {}
	ans = []
	for i in range(n):
		b[a[i]] = i
	flag = n
	for j in range(n, 0, -1):
		if b[j] <= flag:
			for k in range(b[j], flag):
				ans.append(a[k])
			flag = b[j]
	print(*ans)


from collections import deque
t = int(input())
for _ in range(t):
	c = int(input())
	stack = list(map(int, input().split()))
	ans = deque()
	flag = 0
	greatest = stack[0]
	for i in range(1, c):
		if greatest < stack[i]:
			ans.extendleft(reversed(stack[flag:i]))
			flag = i
			greatest = stack[i]
	ans.extendleft(reversed(stack[flag:c]))
	print(*ans, sep=' ')


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	a = list(map(int, input().split()))
	ans = []
	r = [0] * (n + 1)
	for i in range(n):
		r[a[i]] = i
	k = n
	for i in range(n, 0, -1):
		if r[i] <= k:
			for j in range(r[i], k):
				ans.append(a[j])
			k = r[i]
	print(*ans)


t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split(' ')))
	ans = []
	temp = []
	Greater = [arr[0]]
	for k in range(1, n):
		if Greater[k - 1] > arr[k]:
			Greater.append(Greater[k - 1])
		else:
			Greater.append(arr[k])
	for j in range(len(arr) - 1, -1, -1):
		if arr[j] != Greater[j]:
			temp.append(arr[j])
		else:
			temp.append(arr[j])
			ans += temp[::-1]
			temp = []
	print(' '.join(map(str, ans)))


quant_testes = int(input())
for c in range(quant_testes):
	output = ''
	tam = int(input())
	seq = [int(n) for n in input().split()]
	posicoes = [None] * tam
	for i in range(len(seq)):
		posicoes[-seq[i]] = i
	for pos in posicoes:
		if pos + 1 <= tam:
			output += str(seq[pos])
			output += ' '
			for i in range(pos + 1, tam):
				output += str(seq[i])
				output += ' '
				tam -= 1
			tam -= 1
	print(output)


T = int(input())
for t in range(T):
	n = int(input())
	pi = list(map(int, input().split()))
	r = []
	t = [0] * len(pi)
	t[0] = pi[0]
	for i in range(1, len(pi)):
		t[i] = max(t[i - 1], pi[i])
	index = len(pi) - 1
	lastIndex = len(pi)
	while index >= 0:
		while index >= 0 and pi[index] != t[index]:
			index -= 1
		if pi[index] == t[index]:
			r += pi[index:lastIndex]
			lastIndex = index
		index -= 1
	print(' '.join(map(str, r)))


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	li = list(map(int, input().split()))
	bigs = [0]
	current_max = li[0]
	for i in range(1, n):
		if li[i] > current_max:
			current_max = li[i]
			bigs.append(i)
	bigs = reversed(bigs)
	ans = []
	for start in bigs:
		for j in range(start, n):
			ans.append(li[j])
		n = start
	print(*ans)


import sys
import os.path
from collections import *
import math
import bisect
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = sys.stdin.readline
t = int(input())
while t:
	t -= 1
	n = int(input())
	p = [int(x) for x in input().split()]
	arr = [0] * n
	maxval = 0
	for i in range(n):
		maxval = max(p[i], maxval)
		arr[i] = (p[i], maxval)
	arr.sort(key=lambda x: x[1], reverse=True)
	for i in range(n):
		print(arr[i][0], end=' ')
	print()


n = int(input())
for i in range(n):
	m = int(input())
	a = list(map(int, input().split()))
	maxrest = [0 for i in range(m)]
	for j in range(1, m):
		if a[j] > a[maxrest[j - 1]]:
			maxrest[j] = j
		else:
			maxrest[j] = maxrest[j - 1]
	rest = m
	while rest != 0:
		newrest = maxrest[rest - 1]
		for j in range(newrest, rest):
			print(a[j], end=' ')
		rest = newrest


t = int(input())
for j in range(t):
	ans = dict()
	k = int(input())
	d = list(map(int, input().split()))
	ma = d[0]
	ans[0] = ma
	for i in range(1, k):
		if d[i] > ma:
			ma = d[i]
			ans[i] = ma
	ans = list(reversed(ans.keys()))
	b = []
	end = len(ans)
	for i in range(end):
		p = ans[i]
		b += d[p:k]
		k = p
	print(*b)


import sys
input = sys.stdin.readline

def solve():
	n = int(input())
	arr = list(map(int, input().split()))
	S = set()
	mv = n
	tmp = []
	ans = []
	for i in range(n - 1, -1, -1):
		tmp.append(arr[i])
		S.add(arr[i])
		if arr[i] == mv:
			while tmp:
				ans.append(tmp.pop())
			while mv in S:
				mv -= 1
	return ans
for _ in range(int(input())):
	print(*solve())


for s in [*open(0)][2::2]:
	(*l,) = map(int, s.split())
	a = []
	j = len(l)
	a = []
	L = [0]
	for i in range(1, j):
		if l[L[-1]] < l[i]:
			L += [i]
		else:
			L += [L[-1]]
	while j:
		i = L[j - 1]
		a += l[i:j]
		j = i
	print(*a)


for _ in range(int(input())):
	n = int(input())
	li = list(map(int, input().split()))
	tmp = [0] * (n + 1)
	res = []
	for i in range(n):
		tmp[li[i]] = i
	k = n
	for i in range(n, 0, -1):
		if tmp[i] <= k:
			for j in range(tmp[i], k):
				res.append(li[j])
			k = tmp[i]
	print(*res)


from sys import stdin
lst = list(map(int, stdin.read().split()))
_s = 0

def inp(n=1):
	global _s
	ret = lst[_s:_s + n]
	_s += n
	return ret

def inp1():
	return inp()[0]
t = inp1()
for _ in range(t):
	n = inp1()
	c = inp(n)
	new = []
	for i in range(n):
		if len(new) and c[i] < new[-1][0]:
			new[-1].append(c[i])
		else:
			new.append([c[i]])
	new.reverse()
	for i in new:
		for j in i:
			print(j, end=' ')
	print()


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	a = [0] * n
	t = []
	for i in range(n):
		a[arr[i] - 1] = i
	f = n + 1
	for i in range(len(a) - 1, -1, -1):
		if a[i] > f:
			continue
		t.append(arr[a[i]:f])
		f = a[i]
	for i in range(len(t)):
		for j in range(len(t[i])):
			print(t[i][j], end=' ')
	print()


def take_second(elem):
	return elem[0]
q = int(input())
while q > 0:
	n = int(input())
	a = input().split()
	a = [int(x) for x in a]
	list = []
	i = 0
	while i < n:
		if i == 0 or a[i] > a[i - 1]:
			list.append([a[i]])
			list[-1].append(i)
		i += 1
	list = sorted(list, key=take_second)
	b = [0 for i in range(n)]
	ans = []
	i = len(list) - 1
	while i >= 0:
		for j in range(list[i][1], n):
			if b[j] == 0:
				b[j] = 1
				ans.append(a[j])
			else:
				break
		i -= 1
	for i in ans:
		print(i, end=' ')
	print()
	q = q - 1


def solve(arr, size):
	positions = [0] * size
	for j in range(size):
		positions[arr[j] - 1] = j
	K = [positions[size - 1]]
	for j in range(size - 2, -1, -1):
		if positions[j] < K[-1]:
			K.append(positions[j])
	result = [0] * size
	right = size
	pos = 0
	for left in K:
		for j in range(right - left):
			result[pos] = arr[left + j]
			pos += 1
		right = left
	for el in result:
		print(el, end=' ')
	print('')
N = int(input())
for n in range(N):
	L = int(input())
	A = [int(x) for x in input().split()]
	solve(A, L)


import sys
input = sys.stdin.readline
for _ in range(int(input().strip())):
	n = int(input().strip())
	a = list(map(int, input().strip().split(' ')))
	asc = set(a)
	e = n
	o = []
	for i in range(n, 0, -1):
		if i in asc:
			for j in range(e - 1, -1, -1):
				if a[j] == i:
					for k in a[j:e]:
						asc.remove(k)
					o += a[j:e]
					e = j
					break
	print(' '.join(map(str, o)))


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	look = [0] * n
	look[0] = a[0]
	for i in range(1, n):
		look[i] = max(look[i - 1], a[i])
	j = n
	ans = []
	for i in range(n - 1, -1, -1):
		if look[i] == a[i]:
			ans.extend(a[i:j])
			j = i
	print(*ans)


import sys
input = sys.stdin.readline
import math
import bisect
from copy import deepcopy as dc
from itertools import accumulate
from collections import Counter, defaultdict, deque

def ceil(U, V):
	return (U + V - 1) // V

def modf1(N, MOD):
	return (N - 1) % MOD + 1
inf = int(1e+18)
mod = int(1000000000.0 + 7)
t = int(input())
for _ in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	pc = list(accumulate(p, func=max))
	od = []
	prev = n
	for i in range(n - 1, -1, -1):
		if pc[i] == p[i]:
			for j in range(i, prev):
				od.append(p[j])
				prev = i
	for j in range(prev):
		od.append(p[j])
	print(*od)


import os
import sys
from io import BytesIO, IOBase

def main():
	for _ in range(int(input())):
		n = int(input())
		a = list(map(int, input().split()))
		p = [a[0]]
		for i in range(1, n):
			p.append(max(p[-1], a[i]))
		b = [0] * (n + 1)
		for (i, v) in enumerate(a):
			b[v] = i
		ans = []
		i = n - 1
		while p:
			j = b[p[-1]]
			for k in range(j, i + 1):
				ans.append(a[k])
				p.pop()
			i = j - 1
		print(*ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = []
	c = [0 for j in range(n)]
	d = n
	e = n
	for j in range(n - 1, -1, -1):
		c[a[j] - 1] = 1
		if a[j] == d:
			b += a[j:e]
			e = j
			while d > 0 and c[d - 1] == 1:
				d -= 1
	b += a[:e]
	print(*b)


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	k = []
	d = {}
	for i in range(len(l)):
		d[l[i]] = i
	t = int(n)
	for i in range(n, 0, -1):
		if d[i] <= t:
			for j in range(d[i], t):
				k.append(l[j])
			t = d[i]
	print(*k)


def card(n, arr):
	ind = [0] * n
	temp = n
	ans = []
	for i in range(n):
		ind[arr[i] - 1] = i
	for i in ind[::-1]:
		if i < temp:
			ans += arr[i:temp]
			temp = i
	return ans
for i in range(int(input())):
	a = int(input())
	lst = list(map(int, input().strip().split()))
	print(*card(a, lst))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	dic = {}
	result = []
	for i in range(n):
		dic[l[i]] = i
	temp = n
	for i in range(n, 0, -1):
		if dic[i] < temp:
			result.extend(l[dic[i]:temp])
			temp = dic[i]
	print(*result)


t = int(input())
for _ in range(t):
	n = int(input())
	dec = list(map(int, input().split()))
	dic = {}
	for i in range(n):
		dic[dec[i]] = i
	covered_till = n
	new_dec = []
	for i in range(n, 0, -1):
		if dic[i] < covered_till:
			new_dec += dec[dic[i]:covered_till]
			covered_till = dic[i]
	print(*new_dec)


from collections import defaultdict
for _ in range(int(input())):
	n = int(input())
	v = list(map(int, input().split()))
	cnt = 0
	j = n - 1
	i = n - 1
	cur_max = n
	temp = []
	while cnt < n:
		while v[i] != cur_max:
			temp.append(v[i])
			i -= 1
		temp.append(v[i])
		temp.sort(reverse=True)
		flag = 1
		for x in range(1, len(temp)):
			if temp[x - 1] - temp[x] > 1:
				cur_max = temp[x - 1] - 1
				flag = 0
				temp = temp[x:]
				break
		if flag:
			cur_max = temp[len(temp) - 1] - 1
			temp = []
		elif flag != 0 and len(temp) == 1:
			cur_max -= 1
			temp = []
		for k in range(i, j + 1):
			print(v[k], end=' ')
			cnt += 1
		j = i - 1
		i -= 1
	print('')


for _ in range(int(input())):
	n = int(input())
	ps = list(map(int, input().split()))
	dp = [ps[0]]
	for i in range(1, n):
		dp.append(max(dp[-1], ps[i]))
	res = []
	j = n - 1
	temp = [ps[-1]]
	for i in range(n - 2, -1, -1):
		if dp[i] == dp[i + 1]:
			temp.append(ps[i])
		else:
			res += temp[::-1]
			temp = [ps[i]]
	res += temp[::-1]
	print(*res)


from collections import deque
n = int(input())
for _ in range(n):
	c = int(input())
	d = list(map(int, input().split()))
	answer = deque()
	count = 0
	greatest = d[0]
	for i in range(1, c):
		if greatest < d[i]:
			answer.extendleft(reversed(d[count:i]))
			count = i
			greatest = d[i]
	answer.extendleft(reversed(d[count:c]))
	print(*answer, sep=' ')


def cardDeck(n, array):
	array.reverse()
	stack = []
	for x in range(n):
		if not stack:
			stack.append(x)
		else:
			while stack and array[x] > array[stack[-1]]:
				stack.pop()
			stack.append(x)
	ans = []
	prev = 0
	ans += array[stack[0]::-1]
	for x in range(1, len(stack)):
		ans += array[stack[x]:stack[x - 1]:-1]
		prev = stack[x]
	return ans
t = int(input())
final = []
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	final.append(cardDeck(n, l))
for _ in range(t):
	for x in final[_]:
		print(x, end=' ')
	print()


from collections import Counter, deque
from math import *
mod = 998244353

def solve():
	n = int(input())
	l = list(map(int, input().split()))
	val = [i + 1 for i in range(n)]
	cur = val[-1]
	ans = []
	x = n - 1
	z = n - 1
	while x >= 0:
		d = deque()
		while l[x] != cur:
			y = l.pop()
			val[y - 1] = -1
			d.appendleft(y)
			x -= 1
		y = l.pop()
		d.appendleft(y)
		ans += d
		x -= 1
		val[y - 1] = -1
		while z >= 0 and val[z] == -1:
			z -= 1
		cur = val[z]
	print(*ans)
t = int(input())
for _ in range(t):
	solve()


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
inp = lambda : list(map(int, sys.stdin.readline().rstrip('\r\n').split()))
mod = 10 ** 9 + 7
Mod = 998244353
INF = float('inf')
from heapq import *
tc = 1
(tc,) = inp()
for _ in range(tc):
	(n,) = inp()
	a = inp()
	vis = [False] * n
	h = [(-a[i], i) for i in range(n)]
	heapify(h)
	ans = []
	while h:
		(node, ind) = heappop(h)
		if vis[ind] == True:
			continue
		for i in range(ind, n):
			if vis[i] == True:
				break
			vis[i] = True
			ans.append(a[i])
	print(*ans)


def solve():
	n = int(input())
	A = list(map(int, input().split()))
	B = [0] * (n + 1)
	top = n
	pos = n
	(l, r) = (0, n)
	ans = []
	for i in range(n - 1, -1, -1):
		if A[i] == top:
			for x in range(i, r):
				ans.append(A[x])
				B[A[x]] = 1
			r = i
			while B[top]:
				top -= 1
			continue
	return ans
for i in range(int(input())):
	print(*solve())


t = int(input())
for i in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	l = [i for i in range(n, 0, -1)]
	j = n - 1
	k = 0
	b = n - 1
	a = []
	while j >= 0:
		if l[k] > p[j] and l[k] != -1:
			l[n - p[j]] = -1
			j = j - 1
		elif l[k] == p[j] and l[k] != -1:
			a += p[j:b + 1]
			j = j - 1
			b = j
			k = k + 1
		elif l[k] == -1:
			k = k + 1
	print(*a)


def carddeckV2():
	nbCase = int(input())
	res = []
	for i in range(nbCase):
		l_desk = int(input())
		case = [int(j) for j in input().split(' ')]
		M = case[0]
		last = 0
		p_prime = []
		for i in range(len(case)):
			if case[i] > M:
				for j in reversed(range(last, i)):
					p_prime.append(case[j])
				last = i
				M = case[i]
		for j in reversed(range(last, len(case))):
			p_prime.append(case[j])
		res.append(p_prime)
	for r in res:
		s = ''
		for i in reversed(range(len(r))):
			s += str(r[i])
			s += ' '
		print(s)
carddeckV2()


def solve(nums):
	h = {num: i for (i, num) in enumerate(nums)}
	m = [h[str(num)] for num in range(len(nums), 0, -1)]
	result = []
	i_max = len(nums)
	for i in m:
		if i < i_max:
			result += nums[i:i_max]
			i_max = i
	print(' '.join(map(str, result)))
t = int(input().strip())
while t:
	t -= 1
	input()
	solve(input().split())


t = int(input())
for _ in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	d = {}
	for i in range(n):
		d[p[i]] = i
	out = []
	pv = n
	for i in range(n, 0, -1):
		if d[i] <= pv:
			out += p[d[i]:pv]
			pv = d[i]
	print(*out)


import sys, functools, collections, bisect, math
input = sys.stdin.readline
import heapq
t = int(input())
for _ in range(t):
	n = int(input().strip())
	arr = list(map(int, input().strip().split()))
	maxarr = [(arr[0], 0)]
	for i in range(1, n):
		if arr[i] > maxarr[-1][0]:
			maxarr.append((arr[i], i))
		else:
			maxarr.append(maxarr[-1])
	curr = n - 1
	ans = []
	while curr > -1:
		for i in range(maxarr[curr][1], curr + 1):
			ans.append(arr[i])
		curr = maxarr[curr][1] - 1
	print(' '.join((str(i) for i in ans)))


def process(cards):
	maxes = [[cards[0]]]
	n = len(cards)
	for i in range(1, n):
		if cards[i] > maxes[-1][0]:
			maxes.append([cards[i]])
		else:
			maxes[-1].append(cards[i])
	answer = []
	m = len(maxes)
	for i in range(m):
		x = maxes[m - 1 - i]
		for y in x:
			answer.append(y)
	return answer
T = int(input())
for I in range(T):
	n = int(input())
	cards = [int(x) for x in input().split()]
	cards = process(cards)
	cards = ' '.join(map(str, cards))
	print(cards)


import sys

def debug(*args):
	print(*args, file=sys.stderr)

def read_str():
	return sys.stdin.readline().strip()

def read_int():
	return int(sys.stdin.readline().strip())

def read_ints():
	return map(int, sys.stdin.readline().strip().split())

def read_str_split():
	return list(sys.stdin.readline().strip())

def read_int_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def Main():
	t = read_int()
	for _ in range(t):
		n = read_int()
		p = read_int_list()
		note = [0] * n
		for (i, x) in enumerate(p):
			note[~-x] = i
		last = n
		ans = []
		for i in range(n - 1, -1, -1):
			if note[i] < last:
				for j in range(note[i], last):
					ans.append(p[j])
				last = note[i]
		print(*ans)
Main()


import math
for i in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	m = [l[0]]
	k = []
	c = l[0]
	for i in range(1, n):
		if l[i] > c:
			k.append(m)
			m = [l[i]]
			c = l[i]
		else:
			m.append(l[i])
	k.append(m)
	for i in range(len(k) - 1, -1, -1):
		print(*k[i], end=' ')
	print()


def cards(arr, l):
	s = [0]
	maxsof = arr[0]
	for i in range(1, l):
		if maxsof < arr[i]:
			maxsof = arr[i]
			s += [i]
	s = s[::-1]
	upto = l
	t = []
	for i in s:
		for j in range(i, upto):
			t += [arr[j]]
		upto = i
	print(*t)
n = int(input())
while n > 0:
	l = int(input())
	c = [int(i) for i in input().split()]
	cards(c, l)
	n -= 1


for _ in range(int(input())):
	n = int(input())
	li = list(map(int, input().split()))
	b = {}
	li1 = []
	for i in range(n):
		b[li[i]] = i
	ck = n
	for i in range(n, 0, -1):
		if b[i] <= ck:
			for j in range(b[i], ck):
				li1.append(li[j])
			ck = b[i]
	print(*li1)


T = int(input())
for _ in range(T):
	N = int(input())
	A = list(map(int, input().split()))
	ans = list()
	Position = {i: None for i in range(1, N + 1)}
	for (i, elt) in enumerate(A):
		Position[elt] = i
	todo = N
	last = N
	while todo >= 1:
		i = Position[todo]
		ans.extend(A[i:last])
		last = i
		while Position[todo] >= N - len(ans):
			todo -= 1
			if todo < 1:
				break
	print(' '.join(map(str, ans)))


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	dic = dict()
	ans = []
	maxi = n
	for i in range(n):
		dic[arr[i]] = i
	for j in range(n, 0, -1):
		if dic[j] <= maxi:
			ans += arr[dic[j]:maxi]
			maxi = dic[j]
	print(*ans)


_t = int(input())
for t in range(_t):
	n = int(input())
	a = list(map(int, input().split()))
	pos = [0] * (n + 1)
	for i in range(n):
		pos[a[i]] = i
	res = []
	lastpos = n
	for i in range(n, 0, -1):
		p = pos[i]
		if p >= lastpos:
			continue
		res += a[p:lastpos]
		lastpos = p
		if lastpos == 0:
			break
	print(' '.join(map(str, res)))


for i in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	support = []
	mx = 0
	mx1 = n
	n1 = n
	visited = set()
	for i in range(len(l) - 1, -1, -1):
		if l[i] == n1:
			support += l[i:mx1]
			mx1 = i
		visited.add(l[i])
		while n1 in visited:
			n1 -= 1
	print(*support)


test = int(input())
for _ in range(test):
	nn = int(input())
	l = list(map(int, input().split()))
	mark = [0] * (nn + 1)
	i = nn - 1
	j = nn
	ans = []
	while i >= 0 and j >= 1:
		k = i
		while l[k] != j:
			k -= 1
		for index in range(k, i + 1):
			ans.append(l[index])
			mark[l[index]] = 1
		i = k - 1
		while mark[j] == 1:
			j -= 1
	for i in ans:
		print(i, end=' ')
	print()


def debug():
	for i in range(10):
		pass

def mmm(a, b, m):
	res = 0
	a %= m
	while b:
		if b & 1:
			res = (res + a) % m
		a = 2 * a % m
		b >>= 1
	return res

def pw(a, b, c):
	ans = 1
	a = a % c
	if a == 0:
		return 0
	while b > 0:
		if b & 1:
			ans = ans * a % c
		b = b >> 1
		a = a * a % c
	return ans
try:
	for _ in range(int(input())):
		n = int(input())
		arr = [int(i) for i in input().split()]
		arr2 = sorted(arr, reverse=True)
		mp = {}
		for (i, j) in enumerate(arr):
			mp[j] = i
		ans = []
		for i in arr2:
			idx = mp[i]
			ptr = idx
			while ptr < n and arr[ptr] != 0:
				ans.append(arr[ptr])
				arr[ptr] = 0
				ptr += 1
		print(*ans)
except EOFError as e:
	print(e)


__version__ = '0.2'
__date__ = '2021-03-06'
import sys

def solve(n, p):
	answer = []
	pos = [0] * (n + 1)
	for i in range(n):
		pos[p[i]] = i
	cur = n
	for largest in range(n, 0, -1):
		if pos[largest] >= cur:
			continue
		i = pos[largest]
		answer.extend(p[i:cur])
		cur = i
	return answer

def main(argv=None):
	t = int(input())
	for _ in range(t):
		n = int(input())
		p = list(map(int, input().split()))
		print(' '.join(map(str, solve(n, p))))
	return 0
STATUS = main()
sys.exit(STATUS)


from pprint import pprint
import sys
input = sys.stdin.readline

def do():
	from heapq import heappop, heappush, heapify
	n = int(input())
	odat = list(map(int, input().split()))
	dat = []
	for i in range(n):
		dat.append((-odat[i], i))
	heapify(dat)
	res = []
	totteru = n
	while len(dat) > 0:
		(curVal, curInd) = heappop(dat)
		if totteru <= curInd:
			continue
		for i in range(curInd, totteru):
			res.append(odat[i])
		totteru = curInd
	print(' '.join(list(map(str, res))))
q = int(input())
for _ in range(q):
	do()


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [0] * (n + 1)
	ans = []
	for i in range(n):
		b[a[i]] = i
	ck = n
	for i in range(n, 0, -1):
		if b[i] <= ck:
			for j in range(b[i], ck):
				ans.append(a[j])
			ck = b[i]
	print(*ans)


from sys import stdin, stdout
input = stdin.readline
inf = int(1e+20)
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	prev = n
	rem = set()
	m = n
	ans = []
	for i in range(n - 1, -1, -1):
		if arr[i] == m:
			ans += arr[i:prev]
			for d in arr[i:prev]:
				rem.add(d)
			prev = i
			while m in rem:
				m -= 1
	print(' '.join(map(str, ans)))


def segfunc(x, y):
	return max(x, y)
ide_ele = -10 ** 18

class SegTree:

	def __init__(self, init_val, segfunc, ide_ele):
		n = len(init_val)
		self.segfunc = segfunc
		self.ide_ele = ide_ele
		self.num = 1 << (n - 1).bit_length()
		self.tree = [ide_ele] * 2 * self.num
		for i in range(n):
			self.tree[self.num + i] = init_val[i]
		for i in range(self.num - 1, 0, -1):
			self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])

	def update(self, k, x):
		k += self.num
		self.tree[k] = x
		while k > 1:
			self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
			k >>= 1

	def query(self, l, r):
		res = self.ide_ele
		l += self.num
		r += self.num
		while l < r:
			if l & 1:
				res = self.segfunc(res, self.tree[l])
				l += 1
			if r & 1:
				res = self.segfunc(res, self.tree[r - 1])
			l >>= 1
			r >>= 1
		return res
import sys
input = sys.stdin.readline
import math
import copy
t = int(input())
for f in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	ans = []
	a = copy.copy(p)
	a.reverse()
	last = n
	seg = SegTree(p, segfunc, ide_ele)
	flg = seg.query(0, last)
	for i in range(n):
		if a[i] == flg:
			for j in range(n - i - 1, last):
				ans.append(p[j])
			last = n - i - 1
			flg = seg.query(0, last)
	print(*ans)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	p = list(map(int, input().split()))
	q = [(pi, i) for (i, pi) in enumerate(p)]
	q.sort()
	(pi, i) = q.pop()
	np = p[i:]
	while q:
		(npi, ni) = q.pop()
		if ni < i:
			np += p[ni:i]
			i = ni
	print(*np)


for _ in range(int(input())):
	n = int(input())
	a = [*map(int, input().split())]
	ans = []
	j = n
	final = [0] * n
	for i in range(n):
		final[a[i] - 1] = i
	for i in range(n - 1, -1, -1):
		if final[i] < j:
			ans += a[final[i]:j]
			j = final[i]
	print(*ans)


for _ in range(int(input())):
	n = int(input())
	li = list(map(int, input().split()))
	index = [0] * n
	for i in range(n):
		index[li[i] - 1] = i
	temp = n
	ans = []
	for ind in reversed(index):
		if ind < temp:
			ans += li[ind:temp]
			temp = ind
	print(*ans)


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = []
	d = dict()
	t = 0
	ck = []
	for (i, v) in enumerate(a):
		d[v] = i
		t = max(t, v)
		ck.append(t)
	l = n
	while len(b) != n:
		mv = ck[l - 1]
		for i in range(d[mv], l):
			b.append(a[i])
		l = d[mv]
	print(*b)


import os, sys, heapq as h, time
from io import BytesIO, IOBase
from types import GeneratorType
from bisect import bisect_left, bisect_right
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def getMat(n):
	return [getInts() for _ in range(n)]

def isInt(s):
	return '0' <= s[0] <= '9'
MOD = 10 ** 9 + 7

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

def solve():
	N = getInt()
	A = getInts()
	ans = []
	B = SortedList(A)
	while B:
		idx = len(A) - 1
		m = B[-1]
		while A[idx] != m:
			idx -= 1
		for j in range(idx, len(A)):
			ans.append(A[j])
			B.remove(A[j])
		for j in range(idx, len(A)):
			A.pop()
	print(*ans)
	return
for _ in range(getInt()):
	solve()


from sys import *
input = lambda : stdin.readline()
int_arr = lambda : list(map(int, stdin.readline().strip().split()))
for _ in range(int(input())):
	n = int(input())
	arr = int_arr()
	ind = [0] * n
	for i in range(n):
		ind[n - arr[i]] = i
	last = n
	res = []
	for i in range(n):
		if ind[i] <= last:
			res += arr[ind[i]:last]
			last = ind[i]
	print(*res)


import itertools
for _ in range(int(input())):
	n = int(input())
	p = list(map(int, input().split(' ')))
	cands = []
	new_deck = []
	for pi in p:
		if not cands:
			cands.append(pi)
			ord_cands = pi
		elif pi < cands[0]:
			cands.append(pi)
		else:
			new_deck.append(cands)
			cands = [pi]
	new_deck.append(cands)
	print(*itertools.chain.from_iterable(new_deck[::-1]))


from collections import deque

def solve(arr):
	sorted_arr = sorted([(val, idx) for (idx, val) in enumerate(arr)], reverse=True)
	N = len(arr)
	curr_idx = N - 1
	output = []
	i = 0
	while curr_idx >= 0:
		(val, new_idx) = sorted_arr[i]
		if curr_idx < new_idx:
			i += 1
			continue
		for j in range(new_idx, curr_idx + 1):
			output.append(str(arr[j]))
		i += 1
		curr_idx = new_idx - 1
	print(' '.join(output))
	return
t = int(input())
while t:
	t -= 1
	n = int(input())
	arr = [int(val) for val in input().split(' ')]
	solve(arr)


import sys
from collections import *
import math
import bisect

def input():
	return sys.stdin.readline()
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = []
	c = -1
	c1 = []
	for i in range(n):
		if a[i] > c:
			b.append(i)
			c = a[i]
	for i in range(len(b) - 1, -1, -1):
		if len(c1) == 0:
			c1.extend(a[b[i]:])
		else:
			c1.extend(a[b[i]:b[i + 1]])
	print(*c1)


from collections import defaultdict
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.reverse()
	check = n
	ans = []
	tmp = []
	d = defaultdict(int)
	for i in range(n):
		d[a[i]] += 1
		if a[i] == check:
			tmp.append(a[i])
			tmp.reverse()
			ans.append(tmp)
			tmp = []
			while True:
				if d[check] == 1:
					check -= 1
				else:
					break
				if check == 1:
					break
		else:
			tmp.append(a[i])
	ans2 = []
	for ary in ans:
		for i in ary:
			ans2.append(i)
	print(*ans2)


mod = 1000000007
eps = 10 ** (-9)

def main():
	import sys
	input = sys.stdin.readline
	for _ in range(int(input())):
		N = int(input())
		P = list(map(int, input().split()))
		ma = [0] * N
		ma[0] = P[0]
		for i in range(1, N):
			ma[i] = max(ma[i - 1], P[i])
		ans = []
		tmp = []
		m = N
		for i in range(N - 1, -1, -1):
			p = P[i]
			tmp.append(p)
			if p == m:
				tmp.reverse()
				ans.extend(tmp)
				tmp = []
				m = ma[i - 1]
		print(*ans)
main()


for _ in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().split()]
	(ind, ce, ans) = ([0] * n, n, [])
	for i in range(n):
		ind[n - a[i]] = i
	for i in ind:
		if i < ce:
			ans += a[i:ce]
			ce = i
	print(*ans)


for _ in range(int(input())):
	n = int(input())
	p = [int(x) for x in input().split()]
	pref = [0] * n
	pref[0] = p[0]
	for i in range(1, n):
		pref[i] = max(p[i], pref[i - 1])
	pp = [0] * n
	i = n - 1
	x = n
	prev = n
	start = 0
	while i >= 0:
		while i >= 0 and p[i] != pref[i]:
			i -= 1
		for j in range(max(0, i), prev):
			pp[start] = p[j]
			start += 1
		prev = i
		i -= 1
	print(*pp)


import copy
t = int(input())
np = []
ans = []
for _ in range(t):
	np.append([])
	n = int(input())
	np[-1].append(n)
	p = list(map(int, input().split()))
	np[-1].append(p)
for i in range(t):
	n = np[i][0]
	p = np[i][1]
	ans.append([])
	index = [0 for _ in range(n)]
	for j in range(n):
		index[p[j] - 1] = j
	biggest_index = n
	for j in index[::-1]:
		if j < biggest_index:
			ans[-1] += p[j:biggest_index]
			biggest_index = j

def print_list(lst):
	for i in range(len(lst)):
		if i != len(lst) - 1:
			print(lst[i], end=' ')
		else:
			print(lst[i])
for elem in ans:
	print_list(elem)


t = int(input())
for cs in range(t):
	n = int(input())
	p = [int(s) for s in input().split()]
	ans = 0
	pp = []
	mp = [True] * (n + 1)
	currmax = n
	ii = n
	for i in range(n - 1, -1, -1):
		mp[p[i]] = False
		if p[i] == currmax:
			pp += p[i:ii]
			ii = i
			while mp[currmax] == False:
				currmax -= 1
	print(*pp)


t = int(input())
for _ in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	max = 0
	l = []
	for (i, v) in enumerate(p):
		if max < v:
			l.append(i)
			max = v
	ans = []
	f = n
	for i in l[::-1]:
		ans += p[i:f]
		f = i
	print(*ans, sep=' ')


T = int(input())
for t in range(T):
	N = int(input())
	P = list(map(int, input().split()))
	D = [-1 for n in range(N + 1)]
	S = [-1 for n in range(N + 1)]
	for x in range(N):
		D[P[x]] = x
	s = N
	R = []
	stop = N
	while s > 0:
		if S[s] == -1:
			start = D[s]
			for x in range(start, stop):
				R.append(P[x])
				S[P[x]] = 1
			stop = start
		s = s - 1
	print(*R)


t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	maxi = []
	curr = -1
	pos = -1
	for i in range(n):
		if arr[i] > curr:
			curr = arr[i]
			pos = i
		maxi.append([curr, pos])
	ans = []
	pos = n - 1
	while pos >= 0:
		t = maxi[pos][1]
		for i in range(t, pos + 1):
			ans.append(arr[i])
		pos = t - 1
	for i in ans:
		print(i, end=' ')
	print()


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	(q, z, r) = ([0] * n, n, [])
	for i in range(n):
		q[n - a[i]] = i
	for i in q:
		if i < z:
			r += a[i:z]
			z = i
	print(*r)


def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		p = list(map(int, input().split()))
		taken = [0] * (len(p) + 1)
		n_max = n
		last_p = n
		deck = []
		for i in range(n):
			if p[n - i - 1] == n_max:
				for j in range(n - i - 1, last_p):
					deck.append(p[j])
				last_p = n - i - 1
				for j in range(n_max - 1, 0, -1):
					if taken[j] == 0:
						n_max = j
						break
			taken[p[n - i - 1]] = 1
		s = ''
		for d in deck:
			s += str(d) + ' '
		print(s)
main()


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	ind = [0]
	v = l[0]
	for i in range(1, n):
		if l[i] > v:
			v = l[i]
			ind.append(i)
	ind = ind[::-1]
	en = n
	ans = []
	for i in ind:
		for j in range(i, en):
			ans.append(l[j])
		en = i
	print(*ans)


for _ in range(int(input())):
	n = int(input())
	seq = list(map(int, input().split()))
	locmax = [0]
	ans = []
	for i in range(1, n):
		if seq[i] > seq[locmax[-1]]:
			locmax.append(i)
	locmax = [n] + locmax[::-1]
	for el in range(len(locmax) - 1):
		print(*seq[locmax[el + 1]:locmax[el]], end=' ')
	print()


for i in range(int(input())):
	input()
	baralho = list(map(int, input().split(' ')))
	baralho_ordenado = len(baralho) * [0]
	for (indice, carta) in enumerate(baralho):
		baralho_ordenado[carta - 1] = indice
	novo_baralho = []
	while baralho:
		indice_maior_carta = baralho_ordenado.pop()
		if indice_maior_carta < len(baralho):
			novo_baralho += baralho[indice_maior_carta:]
			del baralho[indice_maior_carta:]
	print(' '.join(map(str, novo_baralho)))


T = int(input())
for _ in range(T):
	n = int(input())
	A = list(map(int, input().split()))
	A.reverse()
	ans = []
	temp = []
	ma = -1
	for i2 in range(0, n):
		i = n - i2 - 1
		if A[i] > ma:
			ma = A[i]
			temp.reverse()
			for t in temp:
				ans.append(t)
			temp = []
		temp.append(A[i])
	temp.reverse()
	for t in temp:
		ans.append(t)
	ans.reverse()
	print(*ans)


for _ in range(int(input())):
	n = int(input())
	lis = list(map(int, input().split()))
	look = [0 for i in range(n)]
	look[0] = lis[0]
	for i in range(1, n):
		look[i] = max(look[i - 1], lis[i])
	j = n
	ans = []
	for i in range(n - 1, -1, -1):
		if look[i] == lis[i]:
			ans.extend(lis[i:j])
			j = i
	print(*ans)


def fmax(m, n):
	p = [0 for i in range(n)]
	for i in range(len(m)):
		p[n - m[i]] = i
	return p
for _ in range(int(input())):
	n = int(input())
	m = list(map(int, input().split()))
	p = fmax(m, n)
	index = n
	for i in p:
		if index > i:
			print(*m[i:index], end=' ', sep=' ')
			index = i
	print()


for i in range(int(input())):
	n = int(input())
	deck_list = list(map(int, input().split()))
	max_list = []
	stack = []
	max = -1
	for card in deck_list:
		if card > max:
			max = card
		max_list.append(max)
	for i in range(len(deck_list) - 1, -1, -1):
		if deck_list[i] < max_list[i]:
			stack.append(deck_list[i])
		else:
			print(deck_list[i], end=' ')
			while len(stack) > 0:
				print(stack.pop(), end=' ')
	print()


t = int(input())
while t > 0:
	n = input()
	sz = int(n)
	arr = input().split(' ')
	arr = [int(x) for x in arr]
	pr = [0] * sz
	temp = []
	ans = []
	for i in range(0, int(n)):
		if arr[int(n) - 1 - i] == sz:
			temp.append(arr[int(n) - 1 - i])
			for j in range(0, len(temp)):
				ans.append(temp[len(temp) - 1 - j])
			pr[sz - 1] = 1
			temp = []
			while pr[sz - 1] == 1 and sz > 0:
				sz = sz - 1
		else:
			pr[arr[int(n) - 1 - i] - 1] = 1
			temp.append(arr[int(n) - 1 - i])
	for i in ans:
		print(i, end=' ')
	print('')
	t = t - 1


def solve():
	n = int(input())
	p = [int(x) for x in input().split()]
	visited = [False] * (n + 1)
	res = []
	for i in range(n, 0, -1):
		if not visited[i]:
			tem = []
			while p and p[-1] != i:
				val = p.pop()
				visited[val] = True
				tem.append(val)
			tem.append(p.pop())
			res += tem[::-1]
	print(*res)
for _ in range(int(input())):
	solve()


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	d = dict()
	for i in range(n):
		d[l[i]] = i
	ans = []
	prev = n
	for i in range(n, 0, -1):
		if d[i] <= prev:
			ans += l[d[i]:prev]
			prev = d[i]
	print(*ans)


def fun(ls, var):
	dct = {}
	for (i, val) in enumerate(ls):
		dct[val] = i
	st = sorted(ls)
	last_pop_index = var
	ans = []
	for i in st[::-1]:
		get_index = dct.get(i)
		if get_index < last_pop_index:
			for j in range(get_index, last_pop_index):
				ans.append(ls[j])
			last_pop_index = get_index
	print(*ans)
T = int(input())
for i in range(T):
	v = int(input())
	ls = list(map(int, input().split()))
	fun(ls, v)


t = int(input())
for _ in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	A = [0] * (n + 1)
	i = 0
	while i < n:
		A[p[i]] = i
		i += 1
	i = n
	Lj = n + 1
	answer = ''
	L = n
	while i > 0:
		j = A[i]
		if j >= Lj:
			i -= 1
		else:
			Lj = j
			l = j
			while j < L:
				answer += str(p[j]) + ' '
				j += 1
			L = l
			i -= 1
	print(answer)


def solution():
	t = int(input())
	for _ in range(t):
		n = int(input())
		deck = list(map(int, input().split()))
		deck.reverse()
		marked = (n + 1) * [False]
		ans = []
		i = 0
		for x in range(n, 0, -1):
			if not marked[x]:
				old_i = i
				while deck[i] != x:
					marked[deck[i]] = True
					i += 1
				marked[x] = True
				i += 1
				ans.extend(reversed(deck[old_i:i]))
		print(*ans)
solution()


for _ in range(int(input())):
	n = int(input())
	a = [*map(int, input().split())]
	(ans, t) = ([], n)
	ind = [0] * n
	for i in range(n):
		ind[a[i] - 1] = i
	for i in ind[::-1]:
		if i < t:
			ans += a[i:t]
			t = i
	print(*ans)


import sys
input = sys.stdin.readline

def solve():
	n = int(input())
	p = [0] * (n + 1)
	a = list(map(int, input().split()))
	for i in range(n):
		p[a[i]] = i
	prev = n
	res = []
	for i in range(n, 0, -1):
		if p[i] < prev:
			for j in range(p[i], prev):
				res.append(a[j])
			prev = p[i]
	print(' '.join(map(str, res)))
for i in range(int(input())):
	solve()


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline()

def RL():
	return map(int, sys.stdin.readline().split())

def RLL():
	return list(map(int, sys.stdin.readline().split()))

def N():
	return int(input())

def S():
	return input().strip()

def print_list(l):
	print(' '.join(map(str, l)))
for _ in range(N()):
	n = N()
	a = RLL()
	now = 1
	m = a[0]
	t = []
	for v in a[1:]:
		if v > m:
			t.append(now)
			(now, m) = (1, v)
		else:
			now += 1
	t.append(now)
	ans = []
	r = n
	for v in t[::-1]:
		for i in range(r - v, r):
			ans.append(a[i])
		r -= v
	print_list(ans)


def solve():
	n = int(input())
	a = [int(x) for x in input().split()]
	dic = {}
	for j in range(n):
		dic[a[j]] = j
	ma = n
	temp = []
	for j in range(n, 0, -1):
		if dic[j] < ma:
			for k in range(dic[j], ma):
				temp.append(a[k])
			ma = dic[j]
	print(*temp)
for _ in range(int(input())):
	solve()


import sys
n = int(input())
for _ in range(n):
	nn = int(input())
	cards = list(map(int, sys.stdin.readline().strip().split()))
	max_ = cards[0]
	li = [max_]
	for i in cards[1:]:
		max_ = max(max_, i)
		li.append(max_)
	ali = []
	ans = []
	pre = None
	for (i, v) in enumerate(li[::-1]):
		i = nn - i - 1
		if not (pre == None or pre == v):
			ans.extend(ali[::-1])
			ali = []
		ali.append(cards[i])
		pre = v
	ans.extend(ali[::-1])
	print(' '.join(map(str, ans)))


t = int(input())
r = []
for _ in range(t):
	n = int(input())
	nums = list(input().split())
	pos = [0] * n
	for i in range(n):
		pos[int(nums[i]) - 1] = i
	index = 0
	end = n - 1
	s = ''
	for i in range(n - 1, -1, -1):
		if pos[i] > end:
			continue
		for j in nums[pos[i]:end + 1]:
			print(j, end=' ')
		end = pos[i] - 1


def PROBLEM():
	for _ in range(int(input())):
		n = int(input())
		P = list(map(int, input().split()))
		A = [0] * n
		A[0] = P[0]
		for i in range(1, n):
			A[i] = max(P[i], A[i - 1])
		j = n
		T = []
		for i in range(n - 1, -1, -1):
			if P[i] == A[i]:
				T.extend(P[i:j])
				j = i
		print(*T)
PROBLEM()


import math
import collections

def read_list() -> list:
	return [int(i) for i in input().strip().split()]

def read_num() -> int:
	return int(input().strip())
t = read_num()
for _ in range(t):
	n = read_num()
	init = read_list()
	ans = []
	cnt = n - 1
	mark = [1]
	tmp = init[0]
	for i in range(1, n):
		if init[i] > tmp:
			tmp = init[i]
			mark.append(1)
		else:
			mark.append(0)
	lst = n
	for cnt in range(n - 1, -1, -1):
		if mark[cnt] == 1:
			ans += init[cnt:lst]
			lst = cnt
		cnt -= 1
	for i in ans:
		print(i, end=' ')
	print()


for _ in range(int(input())):
	n = int(input())
	p = list(map(int, input().split()))
	q = []
	ind = []
	mi = -1
	for i in range(n):
		if p[i] > mi:
			ind.append(i)
			mi = p[i]
	ind.append(n)
	n = len(ind)
	for i in range(n - 1):
		q += p[ind[n - 2 - i]:ind[n - 1 - i]]
	print(' '.join([str(o) for o in q]))


t = int(input())
for i in range(t):
	a = int(input())
	l = input().split(' ')
	m = []
	ma = 0
	for j in range(a):
		l[j] = int(l[j])
		if l[j] > l[ma]:
			ma = j
		m.append(ma)
	j = a - 1
	while j >= 0:
		y = j
		j = m[j]
		for k in range(j, y + 1):
			print(l[k], end=' ')
		j -= 1
	print()


from sys import stdin, exit
from bisect import bisect_left as bl, bisect_right as br
from itertools import accumulate
yes = lambda : print('YES')
no = lambda : print('NO')
input = lambda : stdin.readline()[:-1]
intput = lambda : int(input())
sinput = lambda : input().split()
intsput = lambda : map(int, sinput())

def dprint(*args, **kwargs):
	if debugging:
		print(*args, **kwargs)
debugging = 1
t = intput()
for _ in range(t):
	n = intput()
	p = list(intsput())
	indexes = {}
	for (i, x) in enumerate(p):
		indexes[x] = i
	ans = []
	top = n - 1
	target = n
	while top != -1:
		loc = indexes[target]
		if loc <= top:
			ans += p[loc:top + 1]
			top = loc - 1
		target -= 1
	print(' '.join(map(str, ans)))


for _ in range(int(input())):
	n = int(input())
	p = list(map(int, input().split()))
	st = []
	prev = n
	pos = {}
	for i in range(n):
		pos.setdefault(p[i], i)
	for i in range(n, 0, -1):
		if pos[i] <= prev:
			st += p[pos[i]:prev]
			prev = pos[i]
	print(*st)


def solve(P, n):
	moved = [False] * (n + 1)
	nextMax = n
	newDeck = []
	while len(P):
		while moved[nextMax]:
			nextMax -= 1
		stack = []
		while len(P) and P[-1] != nextMax:
			stack.append(P.pop())
		stack.append(P.pop())
		l = len(stack)
		for i in range(l):
			newDeck.append(stack.pop())
			moved[newDeck[-1]] = True
	return newDeck
t = int(input())
for tc in range(t):
	n = int(input())
	P = list(map(int, input().split()))
	result = solve(P, n)
	print(*result)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().strip().split()))
	new = [0] * (n + 1)
	point = n
	lis = []
	for x in range(n - 1, -1, -1):
		if arr[x] == point:
			lis.append(arr[x])
			new[arr[x]] = 1
			print(*lis[::-1], end=' ')
			lis = []
			for y in range(point, 0, -1):
				if new[y] == 0:
					point = y
					break
		else:
			new[arr[x]] = 1
			lis.append(arr[x])


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	new = []
	arr_sort = [i for i in arr]
	arr_sort.sort(reverse=True)
	memo = {arr[i]: i for i in range(n)}
	max_index = n
	indices = []
	for j in range(n):
		i = memo[arr_sort[j]]
		if i < max_index:
			indices.append(i)
			max_index = i
	max_index = n - 1
	for i in indices:
		j = i
		while j <= max_index:
			new.append(arr[j])
			j += 1
		max_index = i - 1
	ans = map(str, new)
	print(' '.join(ans))


from collections import defaultdict
for _ in range(int(input())):
	n = int(input())
	pi = list(map(int, input().split()))
	dp = [0] * n
	curr = n
	right = n
	val = []
	for i in range(n - 1, -1, -1):
		if pi[i] != curr:
			dp[pi[i] - 1] = 1
		else:
			dp[pi[i] - 1] = 1
			val.append(pi[i:right])
			right = i
			for ii in range(curr, -1, -1):
				if not dp[ii - 1]:
					curr = ii
					break
	ans = []
	for i in val:
		for ii in i:
			ans.append(ii)
	print(*ans)


for _ in range(int(input())):
	n = int(input())
	lst = list(map(int, input().split()))
	a = []
	p = n
	pos = {}
	for i in range(n):
		pos.setdefault(lst[i], i)
	for i in range(n, 0, -1):
		if pos[i] <= p:
			a += lst[pos[i]:p]
			p = pos[i]
	print(*a)


class Solution:

	def solution(self, nums):
		points = []
		max_val = float('-inf')
		for i in range(len(nums)):
			if nums[i] > max_val:
				max_val = nums[i]
				points.append(i)
		result = []
		last = len(nums)
		for point in points[::-1]:
			result.extend(nums[point:last])
			last = point
		return result
t = int(input())
for _ in range(t):
	n = int(input())
	nums = list(map(int, input().split()))
	sol = Solution()
	print(str(sol.solution(nums))[1:-1].replace(', ', ' '))


import sys, os, io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def si():
	return input()

def prefix_sum(arr):
	r = [0] * (len(arr) + 1)
	for (i, el) in enumerate(arr):
		r[i + 1] = r[i] + el
	return r

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')

def power_set(L):
	cardinality = len(L)
	n = 2 ** cardinality
	powerset = []
	for i in range(n):
		a = bin(i)[2:]
		subset = []
		for j in range(len(a)):
			if a[-j - 1] == '1':
				subset.append(L[j])
		powerset.append(subset)
	powerset_orderred = []
	for k in range(cardinality + 1):
		for w in powerset:
			if len(w) == k:
				powerset_orderred.append(w)
	return powerset_orderred

def fastPlrintNextLines(a):
	print('\n'.join(map(str, a)))

def sortByFirstAndSecond(A):
	A = sorted(A, key=lambda x: x[0])
	A = sorted(A, key=lambda x: x[1])
	return list(A)
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = 1
t = int(input())
for _ in range(t):
	n = ii()
	l = li()
	d = defaultdict(lambda : 0)
	for i in range(n):
		d[l[i]] = i
	maxpre = [0] * n
	maxpre[0] = l[0]
	for i in range(1, n):
		maxpre[i] = max(maxpre[i - 1], l[i])
	ans = []
	end = n
	i = maxpre[-1]
	while 1:
		ans += l[i:end]
		if i == 0:
			break
		end = i
		i = d[maxpre[i - 1]]
	print(*ans)


def solve(arr, n):
	stack = []
	final_stack = []
	m = float('-inf')
	for i in arr:
		if i > m:
			m = i
			final_stack.append(stack)
			stack = [i]
		else:
			stack.append(i)
	final_stack.append(stack)
	l = []
	for i in final_stack[::-1]:
		l.extend(i)
	return l
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	print(*solve(arr, n), sep=' ')


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	maxi = [l[0]]
	for i in range(1, n):
		maxi.append(max(l[i], maxi[i - 1]))
	ans = []
	temp = []
	l.append(l[-1])
	maxi.append(maxi[-1])
	for i in range(n):
		temp.append(l[i])
		if maxi[i] != maxi[i + 1]:
			ans.append(temp)
			temp = []
	ans.append(temp)
	for i in range(len(ans) - 1, -1, -1):
		print(*ans[i], end=' ')
	print()


import sys
zz = 1
sys.setrecursionlimit(10 ** 5)
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')
di = [[-1, 0], [1, 0], [0, 1], [0, -1]]

def fori(n):
	return [fi() for i in range(n)]

def inc(d, c, x=1):
	d[c] = d[c] + x if c in d else x

def ii():
	return input().rstrip()

def li():
	return [int(xx) for xx in input().split()]

def fli():
	return [float(x) for x in input().split()]

def dadd(d, p, val):
	if p in d:
		d[p].append(val)
	else:
		d[p] = [val]

def gi():
	return [xx for xx in input().split()]

def gtc(tc, ans):
	print('Case #' + str(tc) + ':', ans)

def cil(n, m):
	return n // m + int(n % m > 0)

def fi():
	return int(input())

def pro(a):
	return reduce(lambda a, b: a * b, a)

def swap(a, i, j):
	(a[i], a[j]) = (a[j], a[i])

def prec(a, pre):
	for i in a:
		pre.append(pre[-1] + i)
	pre.pop(0)

def si():
	return list(input().rstrip())

def mi():
	return map(int, input().split())

def gh():
	sys.stdout.flush()

def isvalid(i, j, n, m):
	return 0 <= i < n and 0 <= j < m

def bo(i):
	return ord(i) - ord('a')

def graph(n, m):
	for i in range(m):
		(x, y) = mi()
		a[x].append(y)
		a[y].append(x)
t = fi()
uu = t
while t > 0:
	t -= 1
	n = fi()
	a = li()
	mix = n
	vis = {}
	ans = []
	for i in range(n - 1, -1, -1):
		if a[i] == mix:
			ans.append(a[i])
			print(*ans[::-1], end=' ')
			ans = []
			vis[mix] = 1
			while mix in vis:
				mix -= 1
		else:
			ans.append(a[i])
			vis[a[i]] = 1
	print(*ans[::-1])


entrada = int(input())
for i in range(entrada):
	inpt = input()
	size = [int(i) for i in input().split()]
	ord = [0] * len(size)
	for (i, card) in enumerate(size):
		ord[card - 1] = i
	sizeN = []
	while size:
		i_m_C = ord.pop()
		if i_m_C < len(size):
			sizeN += size[i_m_C:]
			del size[i_m_C:]
	print(' '.join(map(str, sizeN)))


t = int(input())
for case in range(t):
	n = int(input())
	t = list(map(int, input().split()))
	maxi_t = [0] * n
	maxi = t[0]
	for i in range(n):
		maxi = max(maxi, t[i])
		maxi_t[i] = maxi
	rep = []
	split = n
	j = n - 1
	while j >= 0:
		while j >= 0 and t[j] != maxi_t[split - 1]:
			j -= 1
		rep += t[j:split]
		split = j
		j -= 1
	print(*rep)


from math import *
import threading
import sys
from collections import *
mod = 10 ** 9
inf = 10 ** 15
yes = 'YES'
no = 'NO'

def npr(n, r):
	return factorial(n) // factorial(n - r) if n >= r else 0

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(n - r)) if n >= r else 0

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = -1
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = mid
			break
	return ans

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def pref(li):
	pref_sum = [0]
	for i in li:
		pref_sum.append(pref_sum[-1] + i)
	return pref_sum

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	li = []
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for p in range(2, len(prime)):
		if prime[p]:
			li.append(p)
	return li

def primefactors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n //= 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			factors.append(i)
			n //= i
	if n > 2:
		factors.append(n)
	return factors

def prod(li):
	ans = 1
	for i in li:
		ans *= i
	return ans

def dist(a, b):
	d = abs(a[1] - b[1]) + abs(a[2] - b[2])
	return d

def power_of_n(x, n):
	cnt = 0
	while x % n == 0:
		cnt += 1
		x //= n
	return cnt

def ask(l, r):
	if l == r:
		return -1
	print('?', l, r)
	sys.stdout.flush()
	return int(input())
import itertools
sys.setrecursionlimit(300000)
for _ in range(int(input()) if True else 1):
	n = int(input())
	a = list(map(int, input().split()))
	d = defaultdict()
	for i in range(n):
		d[a[i]] = i
	ind = []
	last = n
	for i in range(n, 0, -1):
		for j in range(d[i], last):
			print(a[j], end=' ')
			temp = d[i]
		last = temp
	print('')


t = int(input())
for i in range(t):
	n = int(input())
	k = list(map(int, input().split()))
	lista_card = n * [0]
	for c in range(n):
		lista_card[k[c] - 1] = c
	saida = []
	lista = k
	menor = n
	for e in range(n - 1, -1, -1):
		indice = lista_card[e]
		if indice <= menor:
			saida += k[indice:menor]
			menor = indice
	print(' '.join(map(str, saida)))


from sys import stdin, stdout
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, stdin.readline().split()))
for _ in range(nmbr()):
	n = nmbr()
	a = lst()
	p = 0
	p1 = n
	mx = max(a)
	dp = [0] * n
	for i in range(n):
		dp[i] = max(dp[max(i - 1, 0)], a[i])
	for i in range(n):
		if mx == a[i]:
			p = i
			break
	while p >= 0:
		for i in range(p, p1):
			stdout.write(str(a[i]) + ' ')
		p1 = p
		p -= 1
		while p >= 0:
			if dp[p] == a[p]:
				break
			p -= 1
	print()


import math
T = int(input())
for t in range(T):
	n = int(input())
	c = list(map(int, input().split()))
	m = c[0]
	k = [0]
	for i in range(1, n):
		if c[i] > m:
			k.append(i)
			m = c[i]
	j = k[-1]
	k.pop()
	s = c[j:]
	while len(k):
		s += c[k[-1]:j]
		j = k[-1]
		k.pop()
	print(' '.join(map(str, s)))


from heapq import heappop, heappush, heapify
t = int(input())
while t:
	t -= 1
	n = int(input())
	p = list(map(int, input().split()))
	ans = []
	temp = []
	passed = set()
	curr_max = n
	for i in range(n - 1, -1, -1):
		while curr_max > 0 and curr_max in passed:
			curr_max -= 1
		if p[i] == curr_max:
			temp.append(p[i])
			passed.add(curr_max)
			temp.reverse()
			for j in temp:
				ans.append(j)
			temp = []
		else:
			temp.append(p[i])
			passed.add(p[i])
	for i in ans:
		print(i, end=' ')
	print()


t = int(input())
while t:
	t = t - 1
	n = int(input())
	A = [int(x) for x in input().split()]
	Z = []
	B = dict()
	for x in range(0, n + 1):
		B[x] = x
	i = n - 1
	s = 0
	while i >= 0:
		s = s + 1
		(prev, nm) = B.popitem()
		if A[i] == nm:
			Z.extend(A[i:i + s])
			s = 0
		else:
			B[prev] = nm
		try:
			del B[A[i]]
		except:
			a = 1
		i = i - 1
	print(' '.join(list(map(str, Z))))


import sys

def solve(cards):
	segs = [[cards[0]]]
	temp_max = cards[0]
	for i in range(len(cards)):
		if i == 0:
			continue
		if cards[i] <= temp_max:
			segs[-1].append(cards[i])
		else:
			temp_max = cards[i]
			segs.append([cards[i]])
	return ' '.join([str(num) for seg in segs[::-1] for num in seg])
t = int(sys.stdin.readline().strip())
ans = 0
for _ in range(t):
	n = sys.stdin.readline().strip()
	line = sys.stdin.readline().strip()
	cards = list(map(int, line.split()))
	print(solve(cards))


import os
import sys
import math
from io import BytesIO, IOBase
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def dijkstra(start, distance, path, n):
	visited = [False for _ in range(n)]
	distance[start] = 0
	for i in range(n):
		v = -1
		for j in range(n):
			if not visited[v] and (v == -1 or distance[j] < distance[v]):
				v = j
		if distance[v] == math.inf:
			break
		visited[v] = True
		for edge in adj[v]:
			destination = edge[0]
			weight = edge[1]
			if distance[v] + weight < distance[destination]:
				distance[destination] = distance[v] + weight
				path[destination] = v

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def ncr(n, r):
	return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def npr(n, r):
	return math.factorial(n) // math.factorial(n - r)

def seive(n):
	primes = [True] * (n + 1)
	ans = []
	for i in range(2, n):
		if not primes[i]:
			continue
		j = 2 * i
		while j <= n:
			primes[j] = False
			j += i
	for p in range(2, n + 1):
		if primes[p]:
			ans += [p]
	return ans

def factors(n):
	factors = []
	x = 1
	while x * x <= n:
		if n % x == 0:
			if n // x == x:
				factors.append(x)
			else:
				factors.append(x)
				factors.append(n // x)
		x += 1
	return factors

def main():
	try:
		for _ in range(inp()):
			n = inp()
			a = inlt()
			d = {}
			ans = []
			for i in range(n):
				d[a[i]] = i + 1
			mx = n
			start = d[n]
			while n > 0:
				ans += a[start - 1:n]
				n = start - 1
				if n <= 0:
					break
				while d[mx] > n:
					mx -= 1
				start = d[mx]
			print(*ans, sep=' ')
	except Exception as e:
		print(e)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from collections import OrderedDict
for i in range(int(input())):
	n = int(input())
	inpList = list(map(int, input().split()))
	check_list = OrderedDict.fromkeys(range(1, n + 1))
	last = check_list.popitem()[0]
	new = []
	for i in reversed(range(n)):
		if inpList[i] == last:
			for j in inpList[i:n]:
				if j in check_list:
					check_list.pop(j)
				new.append(j)
			n = i
			if len(check_list) > 0:
				last = check_list.popitem()[0]
	new += inpList[i:n]
	print(' '.join([str(i) for i in new]))


try:
	t = int(input())
	while t != 0:
		n = int(input())
		arr = list(map(int, input().split()))
		temp = []
		for i in range(n):
			temp.append([arr[i], i])
		temp = sorted(temp, key=lambda x: -x[0])
		minimum = n
		p = []
		for i in range(n):
			if i != 0 and minimum > temp[i][1]:
				p += arr[temp[i][1]:minimum]
				minimum = temp[i][1]
			elif i == 0:
				p += arr[temp[i][1]:minimum]
				minimum = temp[i][1]
		print(*p)
		t -= 1
except EOFError:
	print(' ')


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	res = []
	current = a[0]
	start = 0
	for i in range(1, n):
		if a[i] > current:
			sth = a[start:i][::-1]
			start = i
			current = a[i]
			res += sth
	sth = a[start:][::-1]
	res += sth
	for item in res[::-1]:
		print(item, end=' ')
	print('')


from sys import stdin, stdout
t = int(stdin.readline().strip())
outputs = []
for __ in range(t):
	n = int(stdin.readline().strip())
	a = list(map(int, stdin.readline().strip().split()))
	maxm_stack = [a[0]]
	for i in range(1, n):
		maxm_stack.append(max(maxm_stack[-1], a[i]))
	(cur, tot, new) = (1, 0, maxm_stack[-1])
	req = []
	for i in range(n - 1, 0, -1):
		if new == maxm_stack[i - 1]:
			req.append(0)
			tot += 1
		else:
			req.append(cur)
			cur = cur + tot + 1
			new = maxm_stack[i - 1]
			tot = 0
	req.append(cur)
	req.reverse()
	prev = None
	for i in range(n):
		if req[i] == 0:
			req[i] = prev + 1
		prev = req[i]
	res = [''] * n
	for i in range(n):
		res[req[i] - 1] = f'{a[i]}'
	outputs.append(' '.join(res))
for output in outputs:
	stdout.write(output + '\n')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, cards, nums) = (int(input()), [int(i) for i in input().split()], {})
	(ans, last) = ([], n)
	for i in range(n):
		nums[cards[i]] = i
	for i in range(n, 0, -1):
		if nums[i] <= last:
			ans += cards[nums[i]:last]
			last = nums[i]
	print(*ans)


import sys
import math
from bisect import bisect_left
from collections import defaultdict

def get_lcp(s, suffix_array):
	s = s + '$'
	n = len(s)
	lcp = [0] * n
	pos = [0] * n
	for i in range(n - 1):
		pos[suffix_array[i]] = i
	k = 0
	for i in range(n - 1):
		if k > 0:
			k -= 1
		if pos[i] == n - 1:
			lcp[n - 1] = -1
			k = 0
			continue
		else:
			j = suffix_array[pos[i] + 1]
			while max([i + k, j + k]) < n and s[i + k] == s[j + k]:
				k += 1
			lcp[pos[i]] = k
	return lcp

def get_suffix_array(word):
	suffix_array = [('', len(word))]
	for position in range(len(word)):
		sliced = word[len(word) - position - 1:]
		suffix_array.append((sliced, len(word) - position - 1))
	suffix_array.sort(key=lambda x: x[0])
	return [item[1] for item in suffix_array]

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def bin_search(collection, element):
	i = bisect_left(collection, element)
	if i != len(collection) and collection[i] == element:
		return i
	else:
		return -1

def lcm(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		p = list(map(int, input().split()))
		ans = list()
		pref = []
		for i in range(n):
			if i == 0:
				pref.append(p[i])
			else:
				pref.append(max(pref[i - 1], p[i]))
		last = n - 1
		for i in range(n - 1, -1, -1):
			if p[i] == pref[i]:
				ans.append((i, last))
				last = i - 1
		for i in range(len(ans)):
			for j in range(ans[i][0], ans[i][1] + 1):
				print(p[j], end=' ')
		print()
main()


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	p = [0] * (n + 1)
	for (i, x) in enumerate(a):
		p[x] = i
	b = []
	e = n
	for x in range(n, 0, -1):
		if p[x] < e:
			b.extend(a[p[x]:e])
			e = p[x]
	print(*b)


import sys
import math
import statistics

def function(n, p):
	max1 = p[0]
	x = [0]
	ans = []
	m = n
	for i in range(n):
		if p[i] > max1:
			max1 = p[i]
			x.append(i)
	x.reverse()
	for i in x:
		for j in range(i, m):
			ans.append(p[j])
		m = i
	print(*ans)
input = sys.stdin.read()
data = list(map(int, input.split()))
t = data[0]
l = 0
for i in range(t):
	n = data[1 + l]
	p = data[l + 2:l + 2 + n]
	l = l + 1 + n
	function(n, p)


R1 = lambda : list(map(int, input().split()))
R2 = lambda : int(input())
t = R2()
for _ in range(t):
	n = R2()
	A = R1()
	res = ''
	maxis = []
	m = 0
	for i in range(n):
		if A[i] > m:
			m = A[i]
			maxis.append(i)
	l = n
	for i in maxis[::-1]:
		for e in A[i:l]:
			res += str(e) + ' '
		l = i
	print(res)


from collections import deque

def main():
	t = int(input())
	while t:
		n = int(input())
		L = [int(p) for p in input().split()]
		temp = []
		best = -1
		for e in L:
			if e > best:
				best = e
			temp.append(best)
		res = deque()
		for i in range(n - 1, -1, -1):
			res.appendleft(L[i])
			if L[i] == temp[i]:
				print(*res, end=' ')
				res = deque()
		print()
		t -= 1
main()


def solution():
	n = int(input())
	p = [int(i) for i in input().split()]
	p_new = []
	positions = [-1] * (n + 1)
	for i in range(n):
		positions[p[i]] = i
	last_pos = n
	for j in range(n, -1, -1):
		if positions[j] >= last_pos:
			continue
		p_new += p[positions[j]:last_pos]
		last_pos = positions[j]
		if last_pos == 0:
			break
	print(*p_new)
for t in range(int(input())):
	solution()


import os
import sys
from io import BytesIO, IOBase
import math
import itertools
import bisect
import heapq

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)

def countcon(s, i):
	c = 0
	ch = s[i]
	for i in range(i, len(s)):
		if s[i] == ch:
			c += 1
		else:
			break
	return c

def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(1, n):
		for j in range(0, i):
			if arr[i] > arr[j] and lis[i] < lis[j] + 1:
				lis[i] = lis[j] + 1
	maximum = 0
	for i in range(n):
		maximum = max(maximum, lis[i])
	return maximum

def isSubSequence(str1, str2):
	m = len(str1)
	n = len(str2)
	j = 0
	i = 0
	while j < m and i < n:
		if str1[j] == str2[i]:
			j = j + 1
		i = i + 1
	return j == m

def maxfac(n):
	root = int(n ** 0.5)
	for i in range(2, root + 1):
		if n % i == 0:
			return n // i
	return n

def p2(n):
	c = 0
	while n % 2 == 0:
		n //= 2
		c += 1
	return c

def seive(n):
	primes = [True] * (n + 1)
	primes[1] = primes[0] = False
	for i in range(2, n + 1):
		if primes[i]:
			for j in range(i + i, n + 1, i):
				primes[j] = False
	p = []
	for i in range(0, n + 1):
		if primes[i]:
			p.append(i)
	return p

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def denofactinverse(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return pow(fac, m - 2, m)

def numofact(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return fac

def chk(n, d):
	if str(d) in str(n):
		return True
	return False
for xyz in range(0, int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	ans = []
	ind = [-1] * (n + 1)
	maxtillnow = []
	for i in range(0, n):
		ind[l[i]] = i
		if i > 0:
			maxtillnow.append(max(maxtillnow[-1], l[i]))
		else:
			maxtillnow.append(l[i])
	prevind = n
	itc = n - 1
	while itc != -1:
		tind = maxtillnow[itc]
		tind2 = ind[tind]
		ans += l[tind2:prevind]
		prevind = tind2
		itc = prevind - 1
	print(*ans)


t = int(input())
while t != 0:
	n = int(input())
	list1 = list(map(int, input().split()))
	maxi = [list1[0]]
	for i in range(1, n):
		maxi.append(max(maxi[-1], list1[i]))
	ind = n - 1
	ans = []
	while ind >= 0:
		curr = ind + 1
		number = maxi[ind]
		while ind >= 0 and list1[ind] != number:
			ind -= 1
		ans.extend(list1[ind:curr])
		ind -= 1
	print(*ans)
	t -= 1


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	original_deck = list(map(int, input().split()))
	chkList = [False] * (n + 1)
	last_num = original_deck[0]
	chkList[0] = True
	chkList[n] = True
	for i in range(1, n):
		if last_num < original_deck[i]:
			chkList[i] = True
			last_num = original_deck[i]
	for i in range(n - 1, -1, -1):
		if chkList[i]:
			j = i + 1
			print(original_deck[i], end=' ')
			while not chkList[j]:
				print(original_deck[j], end=' ')
				j += 1
	print()


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 10
mod = 10 ** 9 + 7

def LI():
	return list(map(int, input().split()))

def II():
	return int(input())

def LS():
	return list(input().split())

def S():
	return input()

def solve():
	n = II()
	cards = LI()
	cards_max = [0 for _ in range(n)]
	cards_max[0] = cards[0]
	for i in range(1, n):
		cards_max[i] = max(cards_max[i - 1], cards[i])
	res = collections.deque()
	l = n - 1
	r = n
	while r > 0:
		if cards_max[l] == cards[l]:
			res.extend(cards[l:r])
			l -= 1
			r = l + 1
		else:
			l -= 1
	res = [str(i) for i in res]
	print(' '.join(list(res)))

def main():
	n = II()
	for i in range(n):
		solve()
	return 0
main()


def solve(p, n):
	posicoes = [0] * n
	for j in range(n):
		posicoes[p[j] - 1] = j
	K = [posicoes[n - 1]]
	for j in range(n - 2, -1, -1):
		if posicoes[j] < K[-1]:
			K.append(posicoes[j])
	result = [0] * n
	right = n
	pos = 0
	for left in K:
		for j in range(right - left):
			result[pos] = p[left + j]
			pos += 1
		right = left
	return result
t = int(input())
for i in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	print(' '.join(map(str, solve(p, n))))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().strip().split()))
	ah = [i for i in range(n)]
	d = dict(zip(l, ah))
	lan = []
	d[0] = -1
	t = n
	a = n
	while t > 0:
		lan += l[d[t]:a]
		a = d[t]
		for i in range(t - 1, -1, -1):
			if d[i] < a:
				t = i
				break
	print(*lan)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def intArr():
	return map(int, input().split())

def func(arr):
	n = len(arr)
	if n == 1:
		return [1]
	l1 = [0] * n
	for i in range(n):
		l1[arr[i] - 1] = i
	answer = [0] * n
	idx = 0
	ex = n
	curr = n
	while idx < n:
		p = l1[curr - 1]
		while p < ex and idx < n:
			k = arr[p]
			answer[idx] = k
			l1[k - 1] = -1
			p += 1
			idx += 1
		ex = n - idx
		while curr > 0 and l1[curr - 1] == -1:
			curr -= 1
	return answer

def main():
	for _ in range(int(input())):
		_ = int(input())
		arr = list(intArr())
		print(*func(arr))
	return
main()


t = int(input())
for _ in range(t):
	n = int(input())
	nums = [int(tmp) for tmp in input().split()]
	flags = [False] * (n + 1)
	cur = n - 1
	max_cur = n
	while cur >= 0:
		while flags[max_cur]:
			max_cur -= 1
		prev_cur = cur
		while nums[cur] != max_cur:
			flags[nums[cur]] = True
			cur -= 1
		flags[nums[cur]] = True
		for tmp in nums[cur:prev_cur + 1]:
			print(tmp, end=' ')
		cur -= 1
	print()


for _ in range(int(input())):
	n = int(input())
	D = dict()
	res = []
	index = 0
	A = [int(i) for i in input().split()]
	for i in A:
		D[i] = index
		index += 1
	x = n
	j = n
	while D[x] != 0:
		if D[x] < j:
			res += A[D[x]:j]
			j = D[x]
		x -= 1
	res += A[D[x]:j]
	print(*res)


import os
import sys
from io import BytesIO, IOBase
import math
from decimal import *
getcontext().prec = 25
MOD = pow(10, 9) + 7
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split(' ')))
	f = [0] * n
	for i in range(n):
		f[l[i] - 1] = i
	r = []
	z = n
	for i in range(n - 1, -1, -1):
		if f[i] < z:
			r += l[f[i]:z]
			z = f[i]
	print(*r)


import sys, io, os, math
from math import ceil, log, gcd, sqrt
from itertools import permutations
import operator
mod = 1000000007
mod1 = 998244353

def intinp():
	return int(sys.stdin.readline())

def strinp():
	return sys.stdin.readline()

def arrinp():
	return list(map(int, sys.stdin.readline().strip().split()))

def mulinp():
	return map(int, sys.stdin.readline().strip().split())

def flush():
	return stdout.flush()

def power_two(x):
	return 1 << x

def lcm(a, b):
	return a * b // gcd(a, b)

def onescomp(num, d):
	return (1 << d) - 1 ^ num

def solve():
	n = intinp()
	t = arrinp()
	grp = [[t[0]]]
	for i in range(1, n):
		if grp[-1][0] > t[i]:
			grp[-1].append(t[i])
		else:
			grp.append([t[i]])
	grp.sort(reverse=True)
	for i in grp:
		print(*i, end=' ')
	print()

def main():
	tc = intinp()
	while tc:
		solve()
		tc -= 1
main()


import sys
import collections as cc
import math as mt
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
for tc in range(int(input())):
	(n,) = I()
	ar = I()
	ans = []
	fl = n
	te = n
	visi = [0] * (n + 1)
	visi[n] = 1
	for i in range(n - 1, -1, -1):
		visi[ar[i]] = 1
		if ar[i] == fl:
			ans += ar[i:te]
			te = i
			while visi[fl]:
				fl -= 1
	ans += ar[:te]
	print(*ans)


t = int(input())

def ceil(a, b):
	if a % b:
		return a // b + 1
	return a // b
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	maxi = [0]
	for i in range(n):
		maxi.append(max(maxi[-1], l[i]))
	del maxi[0]
	j = n - 1
	ans = []
	while j >= 0:
		m = 1
		j -= 1
		while j >= 0 and maxi[j] == maxi[j + 1]:
			j -= 1
			m += 1
		e = j + 1
		while m:
			ans.append(l[e])
			e += 1
			m -= 1
	print(*ans)


casos = int(input())
for a in range(casos):
	uso = []
	tamanho = int(input())
	final = [0] * tamanho
	sequencia = list(map(int, input().split()))
	menor = len(sequencia)
	maior = len(sequencia)
	for b in range(tamanho):
		final[sequencia[b] - 1] = b
	for c in range(-1, -1 * len(final) - 1, -1):
		if final[c] < menor:
			menor = final[c]
			for d in range(menor, maior, 1):
				uso.append(sequencia[d])
			maior = menor
	print(*uso)


for _ in range(int(input())):
	n = int(input())
	p = list(map(int, input().split()))
	l2 = []
	a = p[0]
	s = [0]
	for i in range(1, n):
		if p[i] > a:
			a = p[i]
			s.append(i)
	s = s[::-1]
	ind = n
	for j in s:
		l2.extend(p[j:ind])
		ind = j
	print(*l2)


import operator
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	maxi = 0
	new_a = []
	local_max_points = []
	for i in range(len(a)):
		if a[i] > maxi:
			maxi = a[i]
			local_max_points.append(i)
	last_point = len(a)
	for point in local_max_points[::-1]:
		new_a += a[point:last_point]
		last_point = point
	print(*new_a)


import sys
from itertools import accumulate
import os
from io import BytesIO, IOBase
from math import ceil
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
T = int(input())
for _ in range(T):
	n = int(input())
	arr = list(map(int, input().split()))
	pos = {v: i for (i, v) in enumerate(arr)}
	ans = []
	right = n
	for i in range(n, 0, -1):
		if pos[i] > right:
			continue
		ans.extend(arr[pos[i]:right])
		right = pos[i]
	print(*ans)


import math
from collections import defaultdict
from sys import stdin
input = stdin.readline
T = int(input())
for _ in range(T):
	n = int(input())
	arr = list(map(int, input().split()))
	l = []
	for i in range(n):
		l.append([arr[i], i])
	l.sort(reverse=True)
	ans = []
	s = set()
	for i in l:
		ind = i[1]
		while ind < n:
			if ind in s:
				break
			else:
				ans.append(arr[ind])
				s.add(ind)
				ind += 1
	print(*ans)


t = int(input())
for _ in range(t):
	n = int(input())
	p = list(map(int, input().split()))
	curMaxs = [0 for _ in range(n)]
	for i in range(1, n):
		curMaxs[i] = curMaxs[i - 1]
		if p[i] > p[curMaxs[i]]:
			curMaxs[i] = i
	x = n - 1
	res = []
	while x >= 0:
		res += p[curMaxs[x]:x + 1]
		x = curMaxs[x] - 1
	print(' '.join([str(x) for x in res]))


n = int(input())
for i in range(n):
	resp = ''
	tam = int(input())
	posicoes = [0] * (tam + 1)
	y = list(map(int, input().strip().split()))[:tam]
	x = [0]
	x.extend(y)
	for i in range(1, tam + 1):
		posicoes[x[i]] = i
	a = tam
	b = tam + 1
	while a > 0:
		if posicoes[a] >= b:
			a -= 1
		else:
			for j in range(posicoes[a], b):
				resp += str(x[j])
				resp += ' '
			b = posicoes[a]
	print(resp.strip())


import re
import sys
exit = sys.exit
from bisect import bisect_left as bsl, bisect_right as bsr
from collections import Counter, defaultdict as ddict, deque
from functools import lru_cache
cache = lru_cache(None)
from heapq import *
from itertools import *
from math import inf
from pprint import pprint as pp
enum = enumerate
ri = lambda : int(rln())
ris = lambda : list(map(int, rfs()))
rln = sys.stdin.readline
rl = lambda : rln().rstrip('\n')
rfs = lambda : rln().split()
d4 = [(0, -1), (1, 0), (0, 1), (-1, 0)]
d8 = [(-1, -1), (0, -1), (1, -1), (-1, 0), (1, 0), (-1, 1), (0, 1), (1, 1)]
t = ri()
for _ in range(t):
	n = ri()
	p = ris()
	hp = []
	for i in range(n):
		heappush(hp, (-p[i], i))
	ans = []
	k = n
	while hp:
		(_, i) = heappop(hp)
		if i >= k:
			continue
		for j in range(i, k):
			ans.append(p[j])
		k = i
	print(*ans)


for _ in range(int(input())):
	n = int(input())
	lis = list(map(int, input().split()))
	index = []
	maxa = 0
	for i in range(len(lis)):
		if lis[i] > maxa:
			index.append(i)
			maxa = lis[i]
	index = index[::-1]
	l = lis[index[0]:]
	for i in range(1, len(index)):
		l.extend(lis[index[i]:index[i - 1]])
	print(*l)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	seen = set(list(range(1, n + 1)))
	search = n
	i = n - 1
	ans = []
	while i >= 0:
		while search not in seen:
			search -= 1
		start = i
		temp = []
		while arr[i] != search:
			temp.append(arr[i])
			seen.remove(arr[i])
			i -= 1
		temp.append(arr[i])
		seen.remove(arr[i])
		ans += temp[::-1]
		i -= 1
	print(*ans)


def int_fn():
	return int(input())

def str_fn():
	return input()

def int_list_fn():
	return [int(val) for val in input().split(' ')]

def solve(n, cards):
	hash_arr = [0] * (n + 1)
	for (idx, card) in enumerate(cards):
		hash_arr[card] = idx
	i = n
	output = []
	limit = n
	while i > 0:
		start_from = hash_arr[i]
		if start_from > limit:
			i -= 1
			continue
		for j in range(start_from, limit):
			output.append(str(cards[j]))
		limit = start_from
		i -= 1
	print(' '.join(output))
	return
for _ in range(int_fn()):
	n = int_fn()
	cards = int_list_fn()
	solve(n, cards)
pass


for _ in range(int(input())):
	n = int(input())
	p = list(map(int, input().split()))
	l1 = p.copy()
	l1.sort()
	m = n - 1
	d1 = dict()
	for i in range(n):
		d1[l1[i]] = i
	ans = []
	store = n
	for i in range(n - 1, -1, -1):
		if p[i] == l1[m]:
			ans += p[i:store]
			store = i
			l1[d1[p[i]]] = -1
			while l1[m] == -1 and m > -1:
				m -= 1
		else:
			l1[d1[p[i]]] = -1
	print(*ans)


import sys
import math

def read_ints():
	inp = input().split()
	inp = [int(x) for x in inp]
	return inp

def read_strings():
	inp = input()
	s = [inp[i] for i in range(len(inp))]
	return s
t = int(input())
for _ in range(t):
	n = int(input())
	p = read_ints()
	elements = [1 for i in range(len(p))]
	ind = n - 1
	i = n - 1
	ans = []
	while i >= 0:
		tmp = []
		while p[i] != ind + 1 and i >= 0:
			elements[p[i] - 1] = 0
			tmp.append(p[i])
			i -= 1
		if i < 0:
			break
		tmp.append(p[i])
		for j in range(len(tmp) - 1, -1, -1):
			ans.append(tmp[j])
		elements[p[i] - 1] = 0
		i -= 1
		ind -= 1
		while elements[ind] == 0 and ind >= 0:
			ind -= 1
	ans = [str(x) for x in ans]
	print(' '.join(ans))


T = int(input())
for t in range(T):
	N = int(input())
	arr = [int(k) for k in input().split()]
	mapping = {}
	for (i, num) in enumerate(arr):
		mapping[num] = i
	res = []
	right = N
	for i in range(N, 0, -1):
		idx = mapping[i]
		if idx >= right:
			continue
		res += arr[idx:right]
		right = idx
	for x in res:
		(print(x, end=' '),)
	print()


class SparseTable:

	def __init__(self, A, ide_ele, f):
		self.n = len(A)
		self.f = f
		max_k = self.n.bit_length() - 1
		self.ide_ele = ide_ele
		self.table = [[ide_ele] * (max_k + 1) for i in range(self.n)]
		for i in range(self.n):
			self.table[i][0] = A[i]
		for k in range(1, max_k + 1):
			k2 = 1 << k - 1
			k3 = (1 << k) - 1
			for i in range(self.n - k3):
				self.table[i][k] = self.f(self.table[i][k - 1], self.table[i + k2][k - 1])

	def query(self, l, r):
		if l >= r:
			return self.ide_ele
		d = r - l
		if d == 1:
			return self.table[l][0]
		k = (d - 1).bit_length() - 1
		k2 = 1 << k
		return self.f(self.table[l][k], self.table[r - k2][k])
INF = 10 ** 18
import sys
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = int(input())
for _ in range(t):
	n = int(input())
	P = list(map(int, input().split()))
	st = SparseTable(P, 0, max)
	ans = []
	cur = n - 1
	while cur >= 0:
		M = st.query(0, cur + 1)
		temp = []
		for i in range(cur, -1, -1):
			temp.append(P[i])
			if P[i] == M:
				cur = i - 1
				break
		temp.reverse()
		for p in temp:
			ans.append(p)
	print(*ans)