/* 2003 MO P-I-2
 *
 * Petr Baudis
 * OKTAVA, gymnazium Ad Fontes Jihlava
 *
 * Pokud se nad problemem zamyslime, dojdeme k prirozenemu predpokladu, ze
 * programator by mel pracovat tim pozdeji, cim mu to bude trvat dele, ale
 * zaroven tim drive, cim vice penez bere na hodinu (p necht je tedy priorita
 * programatora, programatori budou pracovat podle sestupne priority). Z toho
 * plyne vztah p = c / t.
 *
 * Celkovou cenu muzeme zapsat jako
 * C = t[1]*c[1] + (t[1]+t[2])*c[2] + ... + (t[1]+t[2]+...+t[n-1]+t[n])*c[n]
 *
 * Pro libovolne t[a], t[b] (kde T je t[1]+...+t[a-1]) pak muzeme zapsat:
 *
 * C = ... + (T + t[a])*c[a] + (T + t[a] + t[b])*c[b] + ...
 *
 * Pro c[a]/t[a] > c[b]/t[b] tedy toto usporadani ma byt optimalni, tedy:
 *
 * (T+t[a])*c[a]+(T+t[a]+t[b])*c[b] < (T+t[b])*c[b]+(T+t[b]+t[a])*c[a]
 * t[a]*c[a] + t[a]*c[b] + t[b]*c[b] < t[b]*c[b] + t[b]*c[a] + t[a]*c[a]
 * t[a]*c[b] < t[b]*c[a]
 * c[b]/t[b] < c[a]/t[a]
 *
 * Q.E.D.
 *
 * Staci si tedy pro kazdeho programatora spocitat jeho prioritu a pak
 * programatory vhodne (treba quicksortem v O(N * logN)) sestupne setridit.
 * Pametova slozitost bude O(N). */

#include <stdio.h>
#include <stdlib.h>

static struct prog_t { double p; int i; } prog[10000];

int
compar(const struct prog_t *p1, const struct prog_t *p2)
{
  return p2->p - p1->p; /* opacne poradi */
}

int
main()
{
  int n, i;

  scanf("%d", &n);

  for (i = 0; i < n; i++) {
    int c, t;

    scanf("%d %d", &c, &t);
    prog[i].p = c / t;
    prog[i].i = i + 1;
  }

  qsort(prog, n, sizeof(struct prog_t), (int (*)(const void *, const void *)) compar);

  for (i = 0; i < n; i++) {
    printf("%d\n", prog[i].i);
  }

  return 0;
}