Problem:
Score : 200 points

Problem Statement

Sig has built his own keyboard. Designed for ultimate simplicity, this keyboard only has 3 keys on it: the 0 key, the 1 key and the backspace key.

To begin with, he is using a plain text editor with this keyboard. This editor always displays one string (possibly empty). Just after the editor is launched, this string is empty. When each key on the keyboard is pressed, the following changes occur to the string:

The 0 key: a letter 0 will be inserted to the right of the string.

The 1 key: a letter 1 will be inserted to the right of the string.

The backspace key: if the string is empty, nothing happens. Otherwise, the rightmost letter of the string is deleted.

Sig has launched the editor, and pressed these keys several times. You are given a string s, which is a record of his keystrokes in order. In this string, the letter 0 stands for the 0 key, the letter 1 stands for the 1 key and the letter B stands for the backspace key. What string is displayed in the editor now?

Constraints

1 ≦ |s| ≦ 10 (|s| denotes the length of s)

s consists of the letters 0, 1 and B.

The correct answer is not an empty string.

Input

The input is given from Standard Input in the following format:

s

Output

Print the string displayed in the editor in the end.

Sample Input 1

01B0

Sample Output 1

00

Each time the key is pressed, the string in the editor will change as follows: 0, 01, 0, 00.

Sample Input 2

0BB1

Sample Output 2

1

Each time the key is pressed, the string in the editor will change as follows: 0, (empty), (empty), 1.

Solution in C (GCC 9.2.1) (judge verdict: Accepted)

/*  ex9_1
    B30095    */
#include <stdio.h>
#include <stdlib.h>

// stack size
#define SIZE 1000

// definition of stack
typedef struct stack{
    int size;  // stack size
    int count; // number of data
    char data[SIZE];
    char *top;
} stack;

void print_stack_from_bottom(stack *stk);
void initialize_stack(stack *stk);
char pop(stack *stk);
void push(stack *stk, char elem);


int main(void){
    stack stk;
    char ch;

    initialize_stack(&stk);
    
    // process input with stack
    while(1){
        ch = getchar();
        if(ch == '\n' || ch == EOF || ch == '\0') break;  /// end loop if the end of input is reached

        if(ch == 'B'){
            if(stk.count > 0){
                pop(&stk);  // pop an element if backspace is entered and stack is not empty
            }
        }
        // push to stack if character other than backspace is entered
        else{
            push(&stk, ch);
        }
    }

    // print out the stack
    print_stack_from_bottom(&stk);

    return 0;
}


// print stack conetent in FIFO
void print_stack_from_bottom(stack *stk){
    int i;
    for(i = 0; i < stk->count; i++){
        putchar(stk->data[stk->size - i - 1]);
    }
}


// initialize a stack to be empty
void initialize_stack(stack *stk){
    stk->count = 0;
    stk->size = SIZE;
    stk->top = &(stk->data[SIZE]);  // top is at the end of the array
}


// stack push operation
void push(stack *stk, char elem){
    if(stk->count >= stk->size){  // stack overflow
        fprintf(stderr, "Error: stack overflow. (x=%c)\n", elem);
        exit(1);
    }
    else{  // push an element
        stk->top--;
        *(stk->top) = elem;
        stk->count++;
    }
}


// stack pop operation
char pop(stack *stk){
    char latest;
    if(stk->count <= 0){  // stack underflow
        fprintf(stdout, "Error: stack underflow.\n");
        exit(1);
    }
    else{  // pop an element
        latest = *(stk->top);
        stk->top++;
        stk->count--;
        return latest;
    }
}