using System;
using System.Collections.Generic;
using System.IO;

namespace Sandbox
{
    class Program
    {
        struct Restrunt : IComparable<Restrunt>
        {
            public string City;
            public int Point;
            public int CompareTo(Restrunt other)
            {
                var tmp = this.City.CompareTo(other.City);

                if (tmp != 0)
                {
                    return tmp;
                }

                return - this.Point.CompareTo(other.Point);
            }
        }
        static void Main(string[] args)
        {
            var scanner = new Scanner();
            var n = scanner.GetNextAsInt();

            var list = new List<Restrunt>();
            var sorted = new SortedList<Restrunt, Restrunt>();

            for (var i = 0; i < n; i++)
            {
                var city = scanner.GetNext();
                var point = scanner.GetNextAsInt();
                var r = new Restrunt()
                {
                    City = city,
                    Point = point
                };
                sorted.Add(r, r);
                list.Add(r);
            }

            foreach (var item in sorted)
            {
                Console.WriteLine(list.IndexOf(item.Key) + 1);
            }
        }
    }

    #region String Scanner
    public class Scanner
    {
        private const char Separator = ' ';
        private readonly StreamReader _Stream = new StreamReader(Console.OpenStandardInput());
        private int _Pos;
        private string[] _Line = new string[0];

        #region get a element
        public string GetNext()
        {
            // ReSharper disable once InvertIf
            if (this._Pos >= this._Line.Length)
            {
                // ReSharper disable once PossibleNullReferenceException
                this._Line = this._Stream.ReadLine().Split(Separator);
                this._Pos = 0;
            }
            return this._Line[this._Pos++];
        }
        public int GetNextAsInt()
        {
            return int.Parse(this.GetNext());
        }
        public long GetNextAsLong()
        {
            return long.Parse(this.GetNext());
        }
        public double GetNextAsDouble()
        {
            return double.Parse(this.GetNext());
        }
        #endregion

        #region get array
        public string[] ToArrayFromNextLine()
        {
            if (this._Pos >= this._Line.Length)
            {
                // ReSharper disable once PossibleNullReferenceException
                this._Line = this._Stream.ReadLine().Split(Separator);
            }

            this._Pos = this._Line.Length;
            return this._Line;
        }
        public int[] ToIntArrayFromNextLine()
        {
            return ToIntArray(this.ToArrayFromNextLine());
        }
        public long[] ToLongArrayFromNextLine()
        {
            return ToLongArray(this.ToArrayFromNextLine());
        }
        public double[] ToDoubleArrayFromNextLine()
        {
            return ToDoubleArray(this.ToArrayFromNextLine());
        }
        #endregion

        #region convert array
        private static int[] ToIntArray(string[] array)
        {
            var result = new int[array.Length];
            for (var i = 0; i < array.Length; i++)
            {
                result[i] = int.Parse(array[i]);
            }
            return result;
        }
        private static long[] ToLongArray(string[] array)
        {
            var result = new long[array.Length];
            for (var i = 0; i < array.Length; i++)
            {
                result[i] = long.Parse(array[i]);
            }
            return result;
        }
        private static double[] ToDoubleArray(string[] array)
        {
            var result = new double[array.Length];
            for (var i = 0; i < array.Length; i++)
            {
                result[i] = double.Parse(array[i]);
            }
            return result;
        }
        #endregion
    }
    #endregion
}


Measured memory_bytes: 11744