Manipulação de uma pilha

1) A tabela abaixo mostra as operações para a manipulação de uma pilha. (1,0)

PUSH: coloca um elemento novo na pilha.

POP: Retira o elemento do topo da pilha.

Operação Unária: Efetua a operação sobre o elemento do topo da pilha e substitui o elemento do topo pelo resultado.
operações disponíveis: DEC (subtrai o valor 1 do elemento).

Operação binária: Efetua a operação sobre os 2 elementos do topo da pilha, retira os dois elementos do topo da pilha e coloca o resultado da operação no topo da pilha. Operações disponíveis: ADD (adição -> X+Y), SUB (subtração-> Y-X), MPY (multiplicação -> X*Y) e DIV (divisão -> X/Y), onde Y é o elemento no topo da pilha e X o elemento abaixo do Y.

Utilizando as definições acima, a sequência de instruções a seguir foi implementada para avaliar o resultado de uma expressão, sendo A, B, C, D e E os operandos desta expressão. O resultado da avaliação é acumulado em F.

PUSH A

PUSH B

SUB

PUSH C

PUSH D

PUSH E

MPY

ADD

DEC

DIV

POP F

Com base no que foi exposto acima, se A, B, C, D e E apresentarem, respectivamente, os valores 9, 3, 2, 1 e 1, qual o valor armazenado em F após a execução da instrução POP F? A resposta é 3.

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

#define A 9
#define B 3
#define C 2
#define D 1
#define E 1

typedef struct
{

	int valor[6];
	int iIndice;

}pilha;

void Inicializa(pilha *pPilha)
{

	memset(pPilha,0,sizeof(pilha));
	pPilha->iIndice = -1;
}

int EhVazia(pilha *pPilha)
{

	return (pPilha->iIndice < 0) ? 1 : 0;
}

int SUB(int a, int b)
{

	int sub;
	sub = b - a;

	return sub;
}

int MPY(int a, int b)
{

	int mult;
	mult = a * b;

	return mult;
}

void push(pilha *pPilha, int sInsere)
{

	pPilha->iIndice++;
	pPilha->valor[pPilha->iIndice] = sInsere;
}

int top(pilha *pPilha)
{

	return pPilha->valor[pPilha->iIndice];
}

int pop(pilha *pPilha)
{

	int retValor;

	retValor = pPilha->valor[pPilha->iIndice];
	pPilha->iIndice--;

	return retValor;
}

int main()
{

	pilha pValor;
	int x, y, F;

	Inicializa(&pValor);

	push(&pValor, A);
	push(&pValor, B);

	x = pValor.valor[pValor.iIndice];
	y = pValor.valor[pValor.iIndice - 1];

	pop(&pValor);
	pop(&pValor);
	push(&pValor, SUB(x, y));
	push(&pValor, C);
	push(&pValor, D);
	push(&pValor, E);
	x = pValor.valor[pValor.iIndice];
	y = pValor.valor[pValor.iIndice - 1];
	pop(&pValor);
	pop(&pValor);
	push(&pValor, MPY(x, y));

	getchar();
}

Como podem ver estou repetindo a chamada para as variáveis x e y.
Não consegui terminar essa implementação.
Agradeço toda a ajuda