1.

package acm_11525_permutation;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * FWP, AusgewŠhlte Probleme aus dem ACM Programming Contest, SS10 
 * Problem: acm_11525_permutation
 * Link: 
 * 
 * @author Martin Lambeck
 * @version 1.0, 23.10.2010
 * 
 * Method : B-Tree
 * Status : Accepted
 * Runtime: 0.840
 */


public class Main
{
	static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
	static Node root;
	
	public static void main(String... args) throws IOException
	{
		root = Node.init(1, 50001);

		
		int cases = Integer.parseInt(reader.readLine());

		for (int i = 0; i < cases; i++)
			testcase();
	}

	public static void testcase() throws IOException
	{
		int k = Integer.parseInt(reader.readLine());
		String[] si = reader.readLine().split(" ");

		root.reset();

		
		StringBuffer sol = new StringBuffer();
		
		for (int i = 0; i < k; i++)
		{
			int n = Integer.parseInt(si[i]);
			int d = root.get(n).num;

			root.delete(d);
			
			if (i > 0)
				sol.append(" ");
				
			sol.append(d);
		}
		
		System.out.println(sol.toString());
		
	}
}

//B-Tree which allows to delete Items. Items can be accessed by index.
class Node
{
	Node low = null; 	// left/lower subtree
	Node high = null; 	// right/higher subtree
	int num = -1; 		// number of this node
	int lower = -1; 	// number of nodes in left subtree (incl. root of lower subtree)
	int initLower = -1; // value of lower, if no node was deleted (used on reset())
	boolean deleted = false; //this node was deleted
	
	public Node (int n)
	{
		num = n;
	}
	
	public int count() //number of nodes in both subtrees
	{
		return (low != null ? low.count() + 1 : 0) + (high != null ? high.count() + 1 : 0);
	}
	
	public void reset()
	{
		lower = initLower;
		deleted = false;
		
		if (low != null)
			low.reset();
		
		if (high != null)
			high.reset();
	}

	public void delete(int n) //delete Node where num==n
	{
		if (n == num)
			deleted = true;
		
		if (n < num)
			lower--;
		
		if (n < num)
			low.delete(n);
			
		if (n > num)
			high.delete(n);
	}
	
	public Node get(int i) //get Node of INDEX i (starts with 0)
	{
		if ((i == lower) && !deleted)
			return this;
		
		if (i < lower)
			return low.get(i);
		
		return high.get(i - lower - (deleted ? 0 : 1));
	}
	
	static Node init(int from, int to)
	{
		Node nod;
		
		int mid = (to + from) / 2;
		
		nod = new Node(mid);
		
		if ((mid-1) >= from)
			nod.low = init(from, mid-1);
		
		if ((mid+1) <= to)
			nod.high = init(mid+1, to);
	
		nod.initLower = (nod.low != null ? nod.low.count() + 1 : 0); //nodes in low-subtree
		nod.lower = nod.initLower;
		
		return nod;
	}
}