#include "genlib.h"
#include "simpio.h"
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <map>
#include <stdlib.h>

#define I 0;
#define D 1;
#define K 2;
#define C 3;


struct node {
    int val;
    int real; //1 real, 0 not dded, -1 sum
};

char chrs[200000];
int nums[200000];
int arr[200000];
node tree[400000];

int cmpInt(const void *a, const void *b) {
    int a1 = *(int*)a;
    int b1 = *(int*)b;
    if(a1 > b1)
        return 1;
    if(a1 < b1)
        return -1;
    return 0;
}

void updateSum(int init, int index, int start, int end, int realDif, int upDif) {
    if(index < start || index > end || init == index || start == end) return;
    tree[init].real += realDif;
    tree[init].val += upDif;
    updateSum(init*2, index, start, (start+end)/2, realDif, upDif);
    updateSum(init*2+1, index, (start+end)/2 + 1, end, realDif, upDif);


}

int bsrch(int key, int start, int end) {
    if(start >end) return -1;
    int mid = (end  + start)/2;
    if(tree[mid].val == key) return mid;
    if(tree[mid].val > key)
     return bsrch(key, start, mid-1);
    return bsrch(key, mid + 1, end);
}

void IorD(int szLeafs, int toAdd, int ifDoAdd) {
    const void* a = &toAdd;
    int start = szLeafs;
    int end = 2*szLeafs - 1;
    int index = bsrch(toAdd, szLeafs, 2*szLeafs-1);
    if(ifDoAdd == 1) {
        if(tree[index].real == 1) return;
        tree[index].real = 1;
    } else {
        if(tree[index].real == 0) return;
        tree[index].real = 0;
    }
    int up = ifDoAdd*tree[index].val;
    updateSum(1, index, start, end, ifDoAdd, up);
}

//int answerOnC(node* root, int min, int wanted) {
//  if(root->real == 0)
//      return 0;
//  if(root->real == 1) {
//      if(root->val < wanted)
//          return 1;
//      return 0;
//  }
//  return answerOnC(root->left, min, wanted) +
//      answerOnC(root->right, min, wanted);
//}

void fullArr(int size, int curInd, int stInd, int endInd) {
    if(stInd > endInd)
        return;
    if(stInd == endInd) {
        node nd;
        if(stInd > size)
            nd.val = 100000009;
        else {
            nd.val = arr[curInd];
        }
        nd.real = 0;
        tree[curInd] = nd;
    } else {
        fullArr(size, curInd*2, stInd, (stInd + endInd)/2);
        fullArr(size, curInd*2 + 1, (stInd + endInd)/2 + 1, endInd);
        tree[curInd].val = tree[curInd*2 + 1].val + tree[curInd*2].val;
        tree[curInd].real = 0;
        if(tree[curInd*2].real != 0)
            tree[curInd].real += tree[curInd*2].real;
        if(tree[curInd*2+1].real != 0)
            tree[curInd].real += tree[curInd*2+1].real;
    }
}

void readInput(int N, int &size) {
    char got;
    int m;
    map<int, char> mp;
    map<int, char>::iterator it;
    for(int i = 0; i < N; i++) {
        scanf("%c %d\n", &got, &m);
        chrs[i] = got;
        nums[i] = m;
        if(got == 'I') {
            it = mp.find(m);
            if(it == mp.end()) {
                arr[size] = m;
                size++;
                mp[m] = '-';
            }
        }
    }
}


int main() {
    int N;
    scanf("%d\n", &N);
    int size = 0;
    readInput(N, size);
    qsort(arr, size, sizeof(int), cmpInt);
    int getPow = 1;
    for(int i = 1; i < 20; i++) {
        getPow *= 2;
        if(getPow > size)
            break;
    }
    char got;
    fullArr(size, 1, 0, getPow -1);
    for(int i = 0; i < 2*getPow; i++) {
        printf("%d ", tree[i].val);
    }
    scanf("%d\n", &N);
    /*for(int i = 0; i < N; i++) {
        switch(got){
        case('I'):

            break;
        case('D'):

            break;
        case('K'):

            break;
        case('C'):

            //printf("%d\n", answerOnC);
            break;
        }
    }*/

    /*int wholeSize = 2*firstFloor;
    node ** arr = fullArr(wholeSize, firstFloor);*/


    return 0;
}