A

　　

ACboy was kidnapped!! 
he miss his mother very much and is very scare now.You can't image how dark the room he was put into is, so poor :(. 
As a smart ACMer, you want to get ACboy out of the monster's labyrinth.But when you arrive at the gate of the maze, the monste say :" I have heard that you are very clever, but if can't solve my problems, you will die with ACboy." 
The problems of the monster is shown on the wall: 
Each problem's first line is a integer N(the number of commands), and a word "FIFO" or "FILO".(you are very happy because you know "FIFO" stands for "First In First Out", and "FILO" means "First In Last Out"). 
and the following N lines, each line is "IN M" or "OUT", (M represent a integer). 
and the answer of a problem is a passowrd of a door, so if you want to rescue ACboy, answer the problem carefully!

InputThe input contains multiple test cases. 
The first line has one integer,represent the number oftest cases. 
And the input of each subproblem are described above.OutputFor each command "OUT", you should output a integer depend on the word is "FIFO" or "FILO", or a word "None" if you don't have any integer.Sample Input

4
4 FIFO
IN 1
IN 2
OUT
OUT
4 FILO
IN 1
IN 2
OUT
OUT
5 FIFO
IN 1
IN 2
OUT
OUT
OUT
5 FILO
IN 1
IN 2
OUT
IN 3
OUT

Sample Output

1
2
2
1
1
2
None
2
3

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define STACK_INIT_SIZE 50//储存空间初始分配量
#define STACKINCREMENT  10//存储空间分配增量
#define Queue_MAX_SIZE 50
#define OK 1
#define ERROR 0
typedef int QueueType; //队列元素类型
typedef int StackType; //栈元素类型

typedef struct
{
    QueueType *pBase;    //队列指针
    QueueType front;     //队头索引
    QueueType rear;      //队尾索引
    int maxSize;         //当前分配最大容量
}Queue;
//队列的初始化
int InitQueue(Queue *p)
{
    p->pBase = (QueueType *)malloc(Queue_MAX_SIZE * sizeof(QueueType));
    if (p->pBase == NULL) return ERROR; //内存分配失败
    p->front = 0;
    p->rear = 0;     //初始化 队头队尾索引均为0
    p->maxSize = Queue_MAX_SIZE;
    return 0;
}
//销毁队列
void DestroyQueue(Queue *p)
{
    free(p);
    p = NULL;

}
//清空队列
void ClearQueue(Queue *p)
{
    p->front = 0;
    p->rear = 0;
}
//判断队列是否为空
int IsEmpityQueue(Queue *p)
{
    if (p->front == p->rear)
        return OK;
    return ERROR;

}

//判断队列是否满
int IsFullQueue(Queue *p)
{
    if ((p->rear + 1) % p->maxSize == p->front)
        return OK;
    return ERROR;

} 
//新元素入队
int EnQueue(Queue *p, QueueType e)
{
    if (IsFullQueue(p) == OK)
    {
        printf("队列已满
");
        return ERROR;
    }
    p->pBase[p->rear] = e;
    p->rear = (p->rear + 1) % p->maxSize;
    return OK;
}
//队头元素出列
int DeQueue(Queue *p, QueueType *pe)
{
    //如果队列为空 则返回ERROR
    if (IsEmpityQueue(p) == OK)
        return ERROR;


    *pe = p->pBase[p->front];
    p->front = (p->front + 1) % p->maxSize;

    return OK;
}

typedef struct {
    StackType *base;   //在构造之前和销毁之后，base的值为NULL
    StackType *top;    //栈顶指针
    int stacksize;     //当前已分配的存储空间，以元素为单位
}SqStack; //顺序栈

//栈的初始化
int InitStack(SqStack *p)
{
    p->base = (StackType*)malloc(STACK_INIT_SIZE * sizeof(StackType));
    if (p->base == NULL)  return ERROR;  //内存分配失败
    p->top = p->base;     //栈顶与栈底相同表示一个空栈
    p->stacksize = STACK_INIT_SIZE;
    return OK;

}
//判断栈是否为空
int EmptyStack(SqStack *p) {
    //若为空栈 则返回OK，否则返回ERROR
    if (p->top == p->base) return OK;
    else 
        return ERROR;
}
//顺序栈的压入
int Push(SqStack *p, StackType e) {
    //插入元素e为新的栈顶元素
    if ((p->top - p->base) >= p->stacksize)   //栈满，追加储存空间
    {
        p->base = (StackType*)realloc(p->base, (p->stacksize + STACKINCREMENT) * sizeof(StackType));
        if (p->base == NULL)   return ERROR;// 储存空间分配失败
        p->top = p->base + p->stacksize;    //可能有人觉得这句有点多余(我当时也是这么想的 后面有解释)
        p->stacksize += STACKINCREMENT;
    }
    *(p->top) = e;
    (p->top)++;
    return OK;
}
// 顺序栈的弹出     
int Pop(SqStack *p, StackType *e) {
    //若栈不空，则删除p的栈顶元素，用e返回其值
    if (EmptyStack(p) == OK) 
        return ERROR;
    
    --(p->top);
    *e = *(p->top);
    return OK;


}
//顺序栈的销毁
int DestroyStack(SqStack *p) {
    //释放栈底空间并置空
    free(p->base);
    p->base = NULL;
    p->top = NULL;
    p->stacksize = 0;

    return OK;
}
//将顺序栈置空 栈还是存在的，栈中的元素也存在，如果有栈中元素的地址任然能调用
int ClearStack(SqStack *p) {
    p->top = p->base;
    return OK;
}



int main()
{
    int result[100],k=0;
    StackType *se, st;
    SqStack *pstack, stack;
    pstack = &stack;
    se = (StackType*)malloc(sizeof(StackType));    //为指针se分配内存地址
    
    QueueType *qe = (QueueType*)malloc(sizeof(QueueType)),qt;
    Queue *pQueue = (Queue *)malloc(sizeof(Queue));
    InitStack(pstack);                            //初始化栈
    InitQueue(pQueue);    //初始化队列
    int x,y;
    char flag[5],handle[5];
    scanf("%d", &x);
    for (int i = 0; i < x; i++)
    {
        scanf("%d", &y);
        scanf("%s", flag);
        for (int j = 0; j < y; j++)
        {   
            if (strcmp(flag, "FIFO")==0)   //队列
            {
                scanf("%s", handle);
                if (strcmp(handle, "IN") == 0) { scanf("%d", &qt); EnQueue(pQueue, qt); }
                if (strcmp(handle, "OUT") == 0) 
                {
                    if(DeQueue(pQueue, qe)==OK) result[k++]=*qe; 
                    else result[k++] = 99; //99是一个标记
                
                }
                
            }

            if (strcmp(flag, "FILO") == 0)     //栈
            {
                scanf("%s", handle);
                if (strcmp(handle, "IN") == 0) { scanf("%d",&st ); Push(pstack, st); }
                if (strcmp(handle, "OUT") == 0) 
                { 
                    if(Pop(pstack,se)==OK) result[k++]=*se;
                    else
                    result[k++] = 99;
                }
            }
        }
        ClearStack(pstack);
        ClearQueue(pQueue);

    }
    result[k] = '';
    DestroyQueue(pQueue);
    DestroyStack(pstack);
    k = 0;
    while (result[k] != '')
    {
        if (result[k] != 99)
        printf("%d
", result[k]);
        
        else
        printf("None
"); 
    
    k++;    
    }
    return 0;


}