typedef void* QUEUE_DATA;

typedef struct QUEUE_NODE
{
	struct QUEUE_NODE *nextNode;
	QUEUE_DATA data;
} QUEUE_NODE;

typedef struct
{
	QUEUE_ELEM *firstNode, *lastNode;
	int count;
} QUEUE;

void queue_clear(QUEUE *self)
{
	QUEUE_NODE *node = self->firstNode;
	
	while (node)
	{
		QUEUE_NODE *next_node = node->next;
		sys_free(node);
		node = next_node;
	}
}

QUEUE *queue_create()
{
	return sys_malloc(sizeof(QUEUE));
}

void queue_destroy(QUEUE *self)
{
	queue_clear(self);
	sys_free(self);
}

BOOL queue_empty(QUEUE *self)
{
	return self->count == 0;
}

QUEUE_DATA queue_front(QUEUE *self)
{
	if (queue_empty(self))
		return 0;
	
	return self->firstNode->data;
}

QUEUE_DATA queue_pop(QUEUE *self)
{
	if (queue_empty(self))
		return 0;
	
	QUEUE_DATA tmp_data = self->firstNode->data;
	QUEUE_NODE *popped_node = self->firstNode;
	self->firstNode = self->firstNode->nextNode;
	sys_free(popped_node);
	self->count--;
	return tmp_data;
}

void queue_push(QUEUE *self, QUEUE_DATA data)
{
	QUEUE_NODE *node = sys_malloc(sizeof(QUEUE_NODE));

	if (self->lastNode)
		self->lastNode->nextNode = node;
	else
		self->firstNode = node;
	
	self->lastNode = node;
	self->count++;
}

typedef void STACK_TYPE;

typedef struct
{
	STACK_TYPE *data;
	int size, count;
} STACK;

void stack_clear(STACK *self)
{
	self->count = 0;
}

STACK *stack_create(int max_size)
{
	STACK *self = sys_malloc(sizeof(STACK));
	self->data = sys_malloc(max_size * sizeof(STACK_TYPE));
	self->size = max_size;
	return self;
}

void stack_destroy(STACK *self)
{
	sys_free(self->data);
	sys_free(self);
}

BOOL stack_empty(STACK *self)
{
	return self->count == 0;
}

void stack_push(STACK *self, STACK_DATA data)
{
	if (self->count == self->size)
		return;
	
	(self->data)[self->count] = data;
	self->count++;
}

STACK_DATA stack_pop(STACK *self)
{
	if (stack_empty(self))
		return 0;
	
	self->count--;
	return (self->data)[self->count];
}

STACK_DATA stack_top(STACK *self)
{
	if (stack_empty(self))
		return 0;
	
	return (self->data)[self->count - 1];
}