Erro a gravar em ficheiro

boas.

o seguinte codigo esta me a dar erro. nao sei bem porque mas penso k seja da funcao gravar_cenario

se alguem me poder ajudar agradecia desde ja

btw tou a usar o VS 2010

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

typedef struct entradas_saidas
{

	int num_entradas;
	int num_saidas;
}*ENTRADAS_SAIDAS;

typedef struct no
{

	int n_no;
	int num_entradas;
	int num_saidas;
	int dist_anterior;
	struct no *seg, *ant;
}*NO;

typedef struct lista_nos
{

	int num_nos;
	NO no_inicio;
	NO no_fim;
}*LISTA_NOS;

typedef struct via
{

	int num_via;
	LISTA_NOS info;
	struct via *seg;
}*VIA;

typedef struct lista_vias
{

	int n_vias;
	VIA primeira;
}*LISTA_VIAS;

typedef struct estado
{

	int est;
}ESTADO;

LISTA_VIAS criar_lista_vias()
{

	LISTA_VIAS LV;
	LV = (LISTA_VIAS)malloc(sizeof(struct lista_vias));
	LV->primeira = NULL;//ainda não existe informação sobre o 1º nó
	LV->n_vias = 0; //ainda não foram inseridas vias. Campo "total_vias" da estrutura "lista_vias" inicia-se a 0.
	return LV;
}

NO criar_no()
{

	NO N;
	N = (NO)malloc(sizeof(struct no));
	N->n_no = 0;
	N->num_entradas = 0;
	N->dist_anterior = 0;
	N->num_saidas = 0;
	N->ant = NULL;
	N->seg = NULL;
	return N;
}

LISTA_NOS criar_lista_nos()
{

	LISTA_NOS LN;
	LN = (LISTA_NOS)malloc(sizeof(struct lista_nos));
	LN->num_nos=0;
	LN->no_inicio = NULL;//criar_no(); // não existe nó de inicio
	LN->no_fim = NULL;
	return LN;
}

VIA criar_via()
{

	VIA V;
	V = (VIA)malloc(sizeof(struct via)); //alocar estrutura VIA
	V->num_via=0;
	V->info=criar_lista_nos();
	V->seg = NULL;
	return V;
}

ESTADO *alocar_memoria(int n)
{

	ESTADO *p;
	p=(ESTADO *) malloc(n*sizeof(ESTADO));
	return p;
}

void editar_via(LISTA_VIAS lv, VIA v)
{

	int i;
	NO n;
	printf("[via %d]\n",v->num_via);
	printf("numero nos: %d\n",v->info->num_nos);
	n= v->info->no_fim; //indica que n é o nó de inicio
	for(i=v->info->num_nos; i>0; i--)
	{
 printf("\n\nno %d\n",n->n_no);
 printf("dist: %d\n",n->dist_anterior);
 printf("entradas: %d\n",n->num_entradas);
 printf("Saidas: %d\n",n->num_saidas);
 n=n->ant;
	}
}

NO pesquisar_no(LISTA_NOS ln, int n)
{

	int x=1, i;
	NO no_pesquisar = ln->no_inicio;//começa a pesquisar pelo nó de inicio
	while(x)
	{
 if(no_pesquisar->n_no == n) //se o nº do nó_pesquisar é igual ao numero do nó actual
 {
 return no_pesquisar; //devolve o nó pesquisado
 x=0;
 }
 else
 no_pesquisar = no_pesquisar->seg; // passa ao nó seguinte
	}
}

NO inserir_no_lista(LISTA_NOS ln, NO n)
{
if(n->n_no==1) // se estamos no nó 1, então é o nó de inicio.

 ln->no_inicio = n;
	else{
 ln->no_fim = n; // o nó actual é agora o nó de fim
 n->ant = pesquisar_no(ln, ((n->n_no)-1)); //vai pesquisar quem é o nó anterior ao nó actual, e coloca-o no campo ant
	}
	return n;
}

void ler_no(LISTA_NOS ln, NO n, int num_no)
{

	printf("\n NO %d:",num_no);
	n->n_no = num_no;
	if(n->n_no==1)
	{
 printf("\n Distancia desde o inicio (Km): 0\n");
 n->dist_anterior = 0;
	}
	else
	{
 do{
 printf("\n Distancia desde o inicio (Km): ");
 scanf("%d",&(n->dist_anterior));
 }while(n->dist_anterior <= pesquisar_no(ln, num_no-1)->dist_anterior);
 //NOTA: como o nó actual ainda não foi inserido na lista, ainda não sabe quem é o nó anterior.
 // por isso, para verificar se a distancia do nó actual é <= que o nó anterior, faz-se a
 // pesquisa a quem é o nó anterior e vai-se buscar o valor da distancia desse nó.
	}
	do{
 printf(" Numero entradas: ");
 scanf("%d", &(n->num_entradas));
	}while(n->num_entradas<1);

	do{
 printf(" Numero saidas: ");
 scanf("%d", &(n->num_saidas));
	}while(n->num_saidas<1);
}

void ler_via(LISTA_VIAS lv, VIA v)
{

	int i, j;
	//NO n;
	printf("\n\n [VIA %d]\n\n", ++lv->n_vias);
	v->num_via = lv->n_vias; //envia o numero do total de vias para o campo "nº via"
	do{
 printf(" Insira o numero de nos da via: ");
 fflush(stdin);
 scanf("%d", &v->info->num_nos);
	}while(v->info->num_nos<2);

	for(i=1 ; i<=(v->info->num_nos); i++)
	{
 NO n = criar_no();
 ler_no(v->info, n, i);
 inserir_no_lista(v->info, n); //insere o nó no na lista e identifica quem é o no inicio e o no de fim
 n = n->seg; //passa ao nó seguinte
	}
	printf("\n\nno inicio %d", v->info->no_inicio->n_no);
	printf("\nno fim %d", v->info->no_fim->n_no);
	editar_via(lv,v);
}

int comparar_vias(VIA A, VIA B)
{

	VIA VA, VB;
	VA = (VIA) A->num_via;
	VB = (VIA) B->num_via;
	return (VA==VB);
}

void inserir_via_lista(LISTA_VIAS LV, VIA via_nova)
{

	int av=1;
	VIA ant,act; // as variaveis ant e act vao permitir correr a listagem dos elementos á procura do local correcto
	if (LV->primeira==NULL) // se a lista ainda está vazia
	{
 via_nova->seg=NULL;//o campo seguinte passa a estar a null (nao ha seguinte)
 LV->primeira=via_nova;//insere a via no inicio
	}
	else // Se já existem elementos na lista
	{
 ant=act=LV->primeira; // as variaveis ant e act começam no inicio para percorrerem a lista até ao fim

 while(av)
 if(act==NULL) // se o campo act for o ultimo da lista (NULL), o campo avanço passa a 0 e sai do while (a via fica no fim da lista)
 av=0;
 else if((act->num_via, via_nova->num_via)>0)//compara as vias, e se encontrar o seu lugar, pára
 //else if(comparar_vias(act, via_nova)>0)
 av=0;
 else // se ainda não tiver encontrado o seu lugar, avança
 {
 ant=act; //o campo anterior passa ao actual
 act=act->seg; // e o campo actual passa ao seguinte
 }
 if(act==LV->primeira)
 {
 via_nova->seg=LV->primeira;
 LV->primeira=via_nova;
 }
 else
 {
 ant->seg=via_nova;
 via_nova->seg=act;
 }

	}
	//NOTA: Não precisa fazer a adicao de mais um elemento pois já o fez na leitura dos dados.
}

/*
void editar_via(LISTA_VIAS lv, VIA v)
{

	int i;
	printf("[via %d]\n",v->num_via);
	printf("numero nos: %d\n",v->info->num_nos);
	NO n = v->info->no_fim; //indica que n é o nó de inicio
	for(i=1; i<=v->info->num_nos; i--)
	{
 printf("\n\nno %d\n",n->n_no);
 printf("dist: %d\n",n->dist_anterior);
 printf("entradas: %d\n",n->num_entradas);
 printf("Saidas: %d\n",n->num_saidas);
 n=n->ant;
	}

}*/

//********************************************** GRAVAR E LER FICHEIROS *******************************************************

void gravar_cenario(LISTA_VIAS LV)
{

	int num_no, i;
	VIA v;
	NO n;
	FILE *fich = fopen("C:/Users/Julio/Documents/Visual Studio 2010/Projects/codigo/codigo/cenario.ini", "a"); // escreve o ficheiro

	fprintf(fich, "%d\n", LV->n_vias); //escreve no inicio do ficheiro o total de vias
	v = LV->primeira;
	while (v)
	{
 fprintf(fich, "%d\n",v->num_via);
 fprintf(fich, "%d\n",v->info->num_nos);

 n = v->info->no_inicio; //indica que n é o nó de inicio
 //while(n)
 //{
 for(i=1; i<=v->info->num_nos; i++)
 {
 fprintf(fich, "%d\n",n->n_no);
 fprintf(fich, "%d\n",n->dist_anterior);
 fprintf(fich, "%d\n",n->num_entradas);
 fprintf(fich, "%d\n",n->num_saidas);
 n = n->seg;
 }
 v = v->seg;
	}
	fclose(fich);
}

void ler_cenario(LISTA_VIAS lv)
{

	int num_no, i, j;
	FILE *fich=fopen("C:/Users/Julio/Documents/Visual Studio 2010/Projects/codigo/codigo/cenario.ini", "r");

	if(!fich) // se nao foi possivel abrir o ficheiro
	{
 fprintf(stderr, "\n ERRO: Ficheiro config.ini nao encontrado ou insercao de via pela 1a vez.");

	}
	else
	{

 fscanf(fich, "%d", &lv->n_vias); //vai buscar o nº de vias total

 for(i=0; i<lv->n_vias; i++) //irá listar as vias
 {
 VIA v = criar_via(); // cria e inicializa a via
 fscanf(fich, "%d",&v->num_via); // envia
 fscanf(fich, "%d",&v->info->num_nos);

 //NO n = v->info->no_inicio;
 for(j=0; j<v->info->num_nos; j++)
 {
 NO n = criar_no();
 fscanf(fich, "%d",&n->n_no);
 fscanf(fich, "%d",&n->dist_anterior);
 fscanf(fich, "%d",&n->num_entradas);
 fscanf(fich, "%d",&n->num_saidas);
 inserir_no_lista(v->info, n);
 n = n->seg;// = criar_no();
 }
 inserir_via_lista(lv, v);
 v = v->seg;//passa a escrita da via seguinte
 }
 fclose(fich);
	}
}

void gravar_config(ESTADO *e, int n)
{

	FILE *fich = fopen("config.ini", "w");

	if(!fich)
 fprintf(stderr, "\a\nNao foi possivel gravar o ficheiro. \n");
	else{
 fprintf(fich,"%d\n",*e);
 fclose(fich);
	}
}

void ler_config(ESTADO *e, int n)
{

	FILE *fich;

	if((fich=fopen("config.ini", "r"))==NULL)
 fprintf(stderr, "\n | Estado Actual: NAO DEFINIDO |");
 //fprintf(stderr, "\n | Estado Actual: NAO DEFINIDO |");
	else
	{
 fscanf(fich,"%d",&*e);
 fclose(fich);
	}
}

void apagar_historico()
{

	FILE *fich = fopen("simulacao.txt", "w");

	if(!fich)
	{
 printf("\n *-----------------------------------------------------------*");
 printf("\n | ERRO: Nao existe ficheiro para limpar. |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
 //NOTA: se acontecer que o ficheiro nao exista, visto que foi aberto para escrita no inicio da
 // funcao, cria o ficheiro e deixa-o vazio
	}
	else
 fclose(fich);//fecha o ficheiro sem registar nada
}

void mostrar_estado(ESTADO *E)
{
if ((E->est)==1)

 //printf("\n | Estado Actual: INICIADO |");
 printf("\n | Estado Actual: INICIADO |");
	else if((E->est)==2)
 printf("\n | Estado Actual: EM PAUSA |");
 //printf("\n | Estado Actual: EM PAUSA |");
	else if((E->est)==3)
 printf("\n | Estado Actual: DESLIGADO |");
 //printf("\n | Estado Actual: DESLIGADO |");
}

//*************************************************** PESQUISAR *****************************************************

VIA pesquisar_via(LISTA_VIAS lv, int n)
{

	int x=1, i;
	VIA via_pesquisar; //cria a variavel que irá conter a informação da via pesquisada
	via_pesquisar = lv->primeira; //indica que a via_pesquisar corresponde á 1a via da lista
	while(x)
	{
 if(via_pesquisar->num_via == n) //se o nº da via da lista é igual ao numero pesquisado
 {
 return via_pesquisar; //devolve a via pesquisada
 x=0;
 }
 else
 via_pesquisar = via_pesquisar->seg;
	}
	//NOTA: chega a esta função 2 informacoes: LISTA_VIAS e o nº da via pesquisada.
	// esta funcao tem de ir á procura da via com o nº pesquisado, e devolver á main toda a informacao da via
}

//********************************************** REMOVER **************************************************

void libertar_via(VIA via_libertar)
{
free(via_libertar->info); // liberta a lista_vias
free(via_libertar); //liberta a via
}

VIA remover_via(LISTA_VIAS lv, VIA via_remover)
{

	int av=1;
	VIA ret,ant,act;
	if (lv->primeira==NULL)
 ret=NULL;
	else {
 ant=act=lv->primeira;
 while(av)
 if(act==NULL)
 av=0;
 else if(act == via_remover)
 av=0;
 else {
 ant=act;
 act=act->seg;
 }
 if(act!=NULL) {
 ret=act;
 if(lv->primeira==act)
 lv->primeira=act->seg;
 else
 ant->seg=act->seg;
 lv->n_vias--;
 }else
 ret=NULL;
	}
	return ret;

}

void destruir_lista_vias(LISTA_VIAS lv)
{
FILE *fich;
// NOTA:Sempre que é escolhida uma opção do menu "Criar ou Editar cenário", exite leitura do ficheiro. Como tal, se o ficheiro for

	free(lv->primeira);
	lv = criar_lista_vias(); // volta a inicializar a lista de vias, criando tudo de novo
	if(lv->primeira==NULL)
	{
 printf("\n *-----------------------------------------------------------*");
 printf("\n | Todas as vias foram removidas com sucesso! |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
 fich=fopen("cenario.ini", "w"); //limpa ficheiro
 fclose(fich);
	}
	else
	{
 printf("\n *----------------------------------------------------------------*");
 printf("\n | ERRO: Nao foi possivel apagar as vias. Nenhuma via apagada |");
 printf("\n *----------------------------------------------------------------*\n\n\n");
 editar_via(lv, lv->primeira);
	}
}

void remover_via_confirmar(LISTA_VIAS lv, int n)
{

	char op;
	VIA via_pesquisada;

	if(lv->primeira==NULL) //se ainda nao existirem vias adicionadas
	{
 printf("\n *-----------------------------------------------------------*");
 printf("\n | ERRO: Nao existem vias adicionadas para poder eliminar. |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
	}
	else
 if(n>lv->n_vias || n<=0)
 {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | ERRO: A via que indicou nao existe. |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
 }
 else
 {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | Ira perder toda a informacao da via e a numeracao das |");
 printf("\n | vias sera corrigida. Pretende continuar?(S/N) |");
 printf("\n *-----------------------------------------------------------*");
 printf("\n Seleccione opcao: ");
 fflush(stdin);
 op=getchar();
 if(op=='s' || op== 'S')
 {
 via_pesquisada = pesquisar_via(lv, n); //pesquisa a via
 libertar_via(via_pesquisada); //remove a via pesquisada
 if ((pesquisar_via(lv, n))==NULL) //se já nao existir a via
 {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | A via %d foi removida com sucesso! |", n);
 printf("\n *-----------------------------------------------------------*\n\n\n");
// corrigir_numeracao_vias(lv, n);
 }
 else
 {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | ERRO: Nao foi possivel remover a via %d |", n);
 printf("\n *-----------------------------------------------------------*\n\n\n");
 }
 }
 }
}

//******************************************************* MENUS *********************************************************
char menu_principal()
{

	char op;
	do{
 system("cls");
 printf("\n #------------------------------------------------------------------#");
 printf("\n | MENU PRINCIPAL |");
 printf("\n |------------------------------------------------------------------|");
 printf("\n | (1) Criar ou Editar Cenario [+] |");
 printf("\n | (2) Configurar Simulacao |");
 printf("\n | (3) Configurar estado Simulador [+] |");
 printf("\n | (4) Consultar Historico |");
 printf("\n | (5) Limpar Historico |");
 printf("\n | |");
 printf("\n | (0) SAIR |");
 printf("\n #------------------------------------------------------------------#\n");
 fflush(stdin);
 printf("\n Seleccione opcao: ");
 fflush(stdin);
 op=getchar();
	} while (op<'0' || op>'5');
	return op;
}

char menu_editar_cenario()
{

	char op;
	do{
 system("cls");
 printf("\n #------------------------------------------------------------------#");
 printf("\n | MENU PRINCIPAL |");
 printf("\n |------------------------------------------------------------------|");
 printf("\n | (1) CRIAR OU EDITAR CENARIO [-] |");
 printf("\n | (2) Configurar Simulacao #--------------------------------------#");
 printf("\n | (3) Configurar estado Simulador | (1) Inserir via |");
 printf("\n | (4) Consultar historico | (2) Editar via |");
 printf("\n | (5) Limpar historico | (3) Eliminar via |");
 printf("\n | | (4) Eliminar todas as vias |");
 printf("\n | (0) SAIR | |");
 printf("\n #-----------------------------------| (0) VOLTAR AO MENU PRINCIPAL |");
 printf("\n #--------------------------------------#");

 /*
 printf("\n #------------------------------------------------------------------#");
 printf("\n | CRIAR OU EDITAR CENARIO |");
 printf("\n |------------------------------------------------------------------|");
 printf("\n | (1) Adicionar nova via |");
 printf("\n | (2) Editar via |");
 printf("\n | (3) Eliminar via |");
 printf("\n | (4) Eliminar todas as vias |");
 printf("\n | |");
 printf("\n | |");
 printf("\n | (0) VOLTAR MENU PRINCIPAL |");
 printf("\n #------------------------------------------------------------------#\n");
 */
 fflush(stdin);
 printf("\n Seleccione opcao: ");
 fflush(stdin);
 op=getchar();
	} while (op<'0' || op>'4');
	return op;
}

char menu_editar_simulacao(ESTADO *e, int n)
{

	int op, op_tmp;
	do{
 system("cls");
 printf("\n #------------------------------------------------------------------#");
 printf("\n | MENU PRINCIPAL |");
 printf("\n |------------------------------------------------------------------|");
 printf("\n | (1) Criar ou Editar Cenario [+] |");
 printf("\n | (2) Configurar Simulacao #-----------------------------------#");
 printf("\n | (3) Configurar estado Simulador | (1) Iniciar |");
 printf("\n | (4) Consultar historico | (2) Pausar |");
 printf("\n | (5) Limpar historico | (3) Desligar |");
 printf("\n | | (0) VOLTAR AO MENU PRINCIPAL |");
 printf("\n | (0) SAIR | |");
 printf("\n #-----------------------------------| |");
 ler_config(e,n);
 mostrar_estado(e);
 printf("\n #-----------------------------------#");
 /*
 printf("\n #------------------------------------------------------------------#");
 printf("\n | CONFIGURAR ESTADO DO SIMULADOR |");
 printf("\n |------------------------------------------------------------------|");
 printf("\n | (1) Iniciar |");
 printf("\n | (2) Pausar |");
 printf("\n | (3) Desligar |");
 printf("\n | (0) VOLTAR MENU PRINCIPAL |");
 printf("\n | |");
 printf("\n | |");
 printf("\n | |");
 ler_config(e, n);
 mostrar_estado(e);
 printf("\n #------------------------------------------------------------------#\n");
 */
 fflush(stdin);
 printf("\n Seleccione estado: ");
 fflush(stdin);
 scanf("%d",&op);
 //scanf("%d",&e->est);
 //op = e->est;
 }while (op<0 || op>3);
	if(op==0)
 return op;
	else
 e->est = op;
 gravar_config(e, n);
}

// ******************************************** MAIN *************************************************
void main()
{

	int num_estado=1, n_via_edit, n_via_rem;
	char op;
	LISTA_VIAS LV;
	VIA via_remover, via_removida, via_pesquisar, via_nova, v;
	ESTADO *estado;
	estado=alocar_memoria(num_estado);
	LV = criar_lista_vias();

// ler_cenario(LV); // abre o ficheiro cenario.ini

	for(;;)
	{
 system("cls");
 switch (menu_principal())
 {
 case '1':
 switch (menu_editar_cenario())
 {

 case '1':
 //ler_cenario(LV);
 do{

 system("cls");
 printf("\n INSERIR NOVA VIA");
 printf("\n--------------------------------------------------------------------");
 via_nova = criar_via();
 ler_via(LV, via_nova);
 inserir_via_lista(LV, via_nova);
 printf("\n *-----------------------------------------------------------*");
 printf("\n | Pretende adicionar outra via? (S/N) |");
 printf("\n *-----------------------------------------------------------*");
 printf("\n Seleccione opcao: ");
 op=getchar();
 }while (op=='S' || op=='s');
 gravar_cenario(LV);
 break;

 case '2':
 ler_cenario(LV);
 system("cls");
 printf("\n EDITAR VIA");
 printf("\n-----------------------------------------------------------------------------");
 if(LV->primeira==NULL)
 {
 printf("\n\n *----------------------------------------------------------------*");
 printf("\n | OPCAO INACTIVA |");
 printf("\n | Ainda nao foram introduzidas vias para poder editar. Adicione |");
 printf("\n | nova via usando a opcao 1 no menu Criar/Editar cenario. |");
 printf("\n *----------------------------------------------------------------*\n\n\n");
 }
 else{
 printf("\n Editar via numero: ");
 fflush(stdin);
 scanf("%d",&n_via_edit);
 if(n_via_edit>LV->n_vias || n_via_edit<=0) {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | ERRO: A via que tentou pesquisar nao existe. |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
 }else{
 via_pesquisar = pesquisar_via(LV, n_via_edit);
 editar_via(LV, via_pesquisar); //função que edita a via
 }
 }
 break;

 case '3':
 ler_cenario(LV);
 system("cls");
 printf("\n REMOVER VIA");
 printf("\n----------------------------------------------------------------------------");
 if(LV->primeira==NULL)
 {
 printf("\n\n *------------------------------------------------------------------*");
 printf("\n | OPCAO INACTIVA |");
 printf("\n | Ainda nao foram introduzidas vias para poder eliminar. |");
 printf("\n | Adicione nova via usando a opcao 1 no menu Criar/Editar cenario. |");
 printf("\n *------------------------------------------------------------------*\n\n\n");
 }
 else{
 printf("\n Remover a via: ");
 fflush(stdin);
 scanf("%d",&n_via_rem);
 if(n_via_rem>LV->n_vias || n_via_rem<=0)
 {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | ERRO: A via que tentou eliminar nao existe. |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
 }
 else{
 printf("\n *-----------------------------------------------------------*");
 printf("\n | Ira perder toda a informacao da via e a numeracao das |");
 printf("\n | vias sera corrigida. Pretende continuar?(S/N) |");
 printf("\n *-----------------------------------------------------------*");
 printf("\n Seleccione opcao: ");
 fflush(stdin);
 op=getchar();
 if(op=='s' || op== 'S')
 {
 via_remover = pesquisar_via(LV, n_via_rem);
 remover_via(LV, via_remover); //função que remove a via
 if(remover_via(LV, via_remover))
 {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | Via removida com sucesso! |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
 gravar_cenario(LV);
 }
 else
 {
 printf("\n *-----------------------------------------------------------*");
 printf("\n | ERRO: Nao foi possivel eliminar a via. |");
 printf("\n *-----------------------------------------------------------*\n\n\n");
 }
 }
 }
 break;
 }
 break;

 case '4':
 ler_cenario(LV);
 system("cls");
 printf("\n ELIMINAR TODAS AS VIAS");
 printf("\n----------------------------------------------------------------------------\n");
 printf("\n *-----------------------------------------------------------*");
 printf("\n | Esta prestes a apagar todas as vias. Nao podera voltar a |");
 printf("\n | recuperar quaisquer informacoes das vias. |");
 printf("\n | Pretende continuar?(S/N) |");
 printf("\n *-----------------------------------------------------------*");
 printf("\n Seleccione opcao: ");
 fflush(stdin);
 op=getchar();
 if(op=='s' || op== 'S')
 destruir_lista_vias(LV); //NOTA: se a lista foi bem eliminada, o ficheiro cenario.ini é limpo. Ver funçao destruir.
 break;
 }
 break;

 case '3':
 menu_editar_simulacao(estado, num_estado);
 break;

/*

case '4':

 if (lista->nelementos == 0)
 printf("Nao existem elementos na lista!\n");
 else
 mostrar_inversa(lista);
 break;

*/
case '5':

 apagar_historico();
 break;

 case '0':
 exit(0);
 }
 system("pause");
	}
}