An asynchronous system of n processes prone to crashes, along with a number of shared readwrite registers, is the distributed setting. We consider assigning integer numbers to processes in an exclusive manner, in the sense that no integer is assigned to two distinct processes. In the problem called Renaming, any k ≤ n processes, which hold original names from a range [N ] = {1, . . . , N }, contend to acquire unique integers in a smaller range [M ] as new names using some r auxiliary shared registers. We develop a wait-free (k, N )-renaming solution operating in O(log k(log N + log k log log N )) local steps, for M = O(k), and with r = O(k log(N/k)) auxiliary registers. Our approach is based on having processes traverse paths in graphs with suitable expansion properties, where names represent nodes and processes compete for the name of each visited node. We develop a wait-free k-renaming algorithm operating in O(k) time, with M = 2k − 1 and with r = O(k 2 ) registers. We develop an almost adaptive wait-free N -renaming algorithm, with N known, operating in O(log 2 k(log N + log k log log N )) time, with M = O(k) and with r = O(n log(N/n)) registers. We give a fully adaptive solution of Renaming, with neither k nor N known, having M = 8k − lg k − 1 as the bound on new names, operating in O(k) steps and using O(n 2 ) registers. As regards lower bounds, we show that a wait-free solution of Renaming requires 1 + min{k − 2, log 2r N 2M } steps in the worst case. We apply renaming algorithms to obtain solutions to a problem called Store&Collect, which is about operations of storing and collecting under additional requirements. In particular, when both k and N are known, then storing can be performed in O(log k(log N + log k log log N )) steps and collecting in O(k) steps, with r = O(k log(N/k)) registers. Additionally, when N = poly(n) is known but k is not, then storing takes O(log 2 k(log n + log k log log n)) steps and collecting O(k) steps, with O(n log n) registers. We consider the problem called Unbounded-Naming in which processes may repeatedly request new names, while no name can be reused once assigned, so that infinitely many integers need to be exclusively assigned as names in an execution. In such circumstances, for no fixed integer i can one guarantee in a wait-free manner that i is eventually assigned to be a name, so some integers may never be used; the upper bound on the number of such unused integers is used as a measure of quality of a solution. We show that UnboundedNaming is solvable in a non-blocking way such that at most n − 1 nonnegative integers are never assigned as names, which is best possible, and in a wait-free manner such that at most n(n − 1) nonnegative integers are never assigned as names.