C Codigo para controle de atletas

[Lucas Staffa]

estou com esse codigo e não consigo achar o erro, o codigo não executa e nem abre os arquivos que era pra abrir, alguém consegue me ajudar 

<CODE>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <locale.h>
#include <ctype.h>
#include <time.h>
/*01 - Estrutura do endereço*/
typedef struct
{
    char logradouro[52];
    char complemento[52];
    char bairro[52];
    char cidade[52];
    char estado[5];
    char cep[10];
    char alterar[5];
    char salvar[2];
} address;
// - Estrutura do funcionario*/
typedef struct
{
    int codigo;
    char nome[52];
    char celular[13];
    char email[100];
    char cpf[12];
    char usuario[52];
    char senha[52];
    char senha2[60];
    char status[2];
    char alterar[5];
    char salvar[2];
    address endereco;
} user, user_aux, user_upd, user_del;
// - Estrutura do medico*/
typedef struct
{
    int codigo;
    char nome[52];
    char celular[13];
    char email[100];
    char cpf[12];
    char especialidade[52];
    char alterar[5];
    char salvar[2];
}doctor, doctor_aux, doctor_upd, doctor_del;
//Estrutura da Modalidade olimpica
typedef struct
{
    char modalide[52];
    char salvar[2];
} mod, mod_aux, mod_upd, mod_del;

// Estrutura do Pais
typedef struct
{
    char regiao[52];
    char pais[52];
    char salvar[2];
} country, country_aux, country_upd, country_del;

// Estrutura do  Atleta
typedef struct
{
    int codigo;
    char nome[52];
    char salvar[2];
    char pais[52];
} athlete, athlete_aux, athlete_upd, athlete_del;

// Estrutura da Equipe Ol�mpica
typedef struct
{
    char atleta[52];
    doctor medico;
    char pais[52];
    char salvar[2];
} equipep,equipep_aux,equipep_upd,equipep_del;
// Estrutura do Alojamento
typedef struct
{
    char logradouro[52];
    char complemento[52];
    char bairro[52];
    char cidade[52];
    char estado[5];
    char cp[10];
    char alterar[5];
    char salvar[2];
} alojamentop,alojamentop_aux,alojamentop_upd,alojamentop_del;
//Estrutura do Local dos jogos Ol�mpicos
typedef struct
{
    char logradouro[52];
    char complemento[52];
    char bairro[52];
    char cidade[52];
    char estado[5];
    char cp[10];
    char alterar[5];
    char salvar[2];
} localp,localp_aux,localp_upd,localp_del;
// Estrutura local de treinamento
typedef struct
{

    char logradouro[52];
    char complemento[52];
    char bairro[52];
    char cidade[52];
    char estado[5];
    char cp[10];
    char alterar[5];
    char salvar[2];
} localtrein, local_trein_aux, local_trein_upd, local_trein_del;
//Estrutura do agendamento*/
typedef struct
{
    int codigo;
    char cpf[12];
    doctor medico;
    localtrein lugar;
    char data[10];
    char hora[6];
    athlete atleta;
    char descricao[50];
    char alterar[5];
    char salvar[2];
} scheduling, scheduling_aux, scheduling_upd, scheduling_del;

FILE *pmodalidade, *ptreint, *pequipe, *ppais, *pfuncionario, *pagendamento, *temporario, *pdoctor, *patleta;

// MENU
int main(void);
int main_principal(void);
void main_cadastro(void);
void main_consulta(void);
void main_alterar(void);
void main_delete(void);
//MENU TELAS
void menu_principal(void);
void menu_cadastros(void);
void menu_consultas(void);
void menu_alterar(void);
void menu_delete(void);
//CADASTRO TELAS
void cad_funcionario(void);
void cad_atleta(void);
void cad_medico(void);
void cad_local_treinamento(void);
void cad_agendamento(void);
void cad_equipe(void);
void cad_pais(void);
void cad_local(void);
//FC CONSULTA TELAS
int con_funcionario(void);
int con_atleta(void);
int con_medico(void);
int con_local_treinamento(void);
int con_agendamento(void);
int con_equipe(void);
int con_pais(void);
int con_local(void);
//FC ALTERAR TELAS
void alterar_funcionario(void);
void alterar_atleta(void);
void alterar_medico(void);
void alterar_local_treinamento(void);
void alterar_agendamento(void);
void altera_equipe(void);
//FC DELETAR TELAS
void deletar_funcionario(void);
void deletar_atleta(void);
void deletar_medico(void);
void deletar_local_treinamento(void);
void cancelar_agendamento(void);
//FC ALEATORIAS
int verifica_useradm(void);
int tela_login(void);
//FC ALEATORIAS
int verifica_useradm(void);
int tela_login(void);
int verifica_useradm(void);
int tela_login(void);
void mostrarendereco(void);
void tratamento_desc50(char *tdesc50, int tdesc50_size);
void tratamento_codigo(char *tcodigo50, int tcodigo50_size);
void tratamento_cp(char *tcp50, int tcp50_size);
void tratamento_nome(char *tnome50, int tnome50_size);
void tratamento_country(char *tpais50, char tcountry50_size);
void tratamento_desc1500(char *tdesc1500, int tdesc1500_size);
void tratamento_estado(char *testado, int testado_size);
void tratamento_nome(char *tnome, int tnome_size);
void tratamento_cpf(char *tcpf, int tcpf_size);
void tratamento_data(char *tdata, int tdata_size);
void tratamento_tdta(char *tdta, int tdta_size);
void tratamento_dataqq(char *tdataqq, int tdataqq_size);
void tratamento_tdtaqq(char *tdtaqq, int tdtaqq_size);
void tratamento_hora(char *thora, int thora_size);
void tratamento_numero(char *tnum, int tnum_size);
void tratamento_numeroum(char *tnumum, int tnumum_size);
void tratamento_hm(char *thm, int thm_size);
void tratamento_cnpj(char *tcnpj, int tcnpj_size);
void tratamento_senha(char *tsenha, int tsenha_size);
void tratamento_celular(char *tcelular, int tcelular_size);
void tratamento_cep(char *tcep, int tcep_size);
void criptografa_senha(char *crip_msg, int senha_encript_size);
void incrementa_id_func(int *IDinc);
void incrementa_id_atle(int *IDinc_atle);
void incrementa_id_medi(int *IDinc_medi);
void incrementa_id_fili(int *IDinc_fili);
void incrementa_id_agen(int *IDinc_agen);
void incrementa_id_avale(int *IDinc_avale);
void incrementa_id_avalr(int *IDinc_avalr);

/*MENU PRINCIPAL*/
int main(void)
{
    setlocale(LC_ALL, "Portuguese");
    verifica_useradm();
    tela_login();
    main_principal();
    return 0;
}

int main_principal(void)
{
    /*---- ACESSO AOS MENU DE CADASTRO E CONSULTA ----*/
    char scan_main[2];
    memset(scan_main, 0, sizeof(scan_main));

    /*Chama o menu princial*/
    menu_principal();

    printf("\nSelecione uma opcao e pressione ENTER: ");
    tratamento_numeroum(scan_main, 0);

    switch (scan_main[0])
    {
    case '1':
        main_cadastro();
        break;
    case '2':
        main_consulta();
        break;
    case '3':
        main_alterar();
        break;
    case '4':
        main_delete();
        break;
    case '5':
        tela_login();
        break;
    case '6':
        exit(0);
        break;
    default:
        printf("\n\nMenu inexistente, tente novamente de 1 a 6.\n\n");
        system("pause");
        main_principal();
    }

    printf("\n\n");
    return 0;
}

void main_cadastro(void)
{
    /*---- ACESSO AOS MENU DE CADASTRO E CONSULTA ----*/
    char scan_cad[2];
    memset(scan_cad, 0, sizeof(scan_cad));

    /*Chama o menu de cadastros*/
    menu_cadastros();

    printf("\nSelecione uma opcao e pressione ENTER: ");
    tratamento_numeroum(scan_cad, 0);

    switch (scan_cad[0])
    {
    case '1':
        cad_funcionario();
        break;
    case '2':
        cad_atleta();
        break;
    case '3':
        cad_medico();
        break;
    case '4':
        cad_local_treinamento();
        break;
    case '5':
        cad_agendamento();
        break;
    case '6':
        cad_equipe();
        break;
    case '7':
        cad_pais();
    case '8':
        cad_local();
    case '9':
        main_principal();
    case '0':
        tela_login();
        break;
        exit(0);
    default:
        printf("\n\nMenu inexistente, tente de 0 a 9.\n\n");
        system("pause");
        main_cadastro();
    }

    printf("\n\n");
}

void main_consulta(void)
{
    /*---- ACESSO AOS MENU DE CADASTRO E CONSULTA ----*/
    char scan_con[2];
    memset(scan_con, 0, sizeof(scan_con));

    /*Chama o menu de consultas*/
    menu_consultas();

    printf("\nSelecione uma opcao e pressione ENTER: ");
    tratamento_numeroum(scan_con, 0);

    switch (scan_con[0])
    {
    case '0':
        con_funcionario();
        break;
    case '1':
        con_atleta();
        break;
    case '2':
        con_medico();
        break;
    case '3':
        con_local_treinamento();
        break;
    case '4':
        con_agendamento();
        break;
    case '5':
        con_equipe();
        break;
    case '6':
        con_pais();
    case '7':
        con_local();
        break;
    case '8':
        main_principal();
        break;
    case '9':
        tela_login();
        exit(0);
    default:
        printf("\n\nMenu inexistente, tente de 1 a 7.\n\n");
        system("pause");
        main_consulta();
    }

    printf("\n\n");
    getchar();
}

void main_alterar(void)
{
    /*---- ACESSO AOS MENU DE CADASTRO E CONSULTA ----*/
    char scan_alt[2];
    memset(scan_alt, 0, sizeof(scan_alt));

    /*Chama o menu de alteração*/
    menu_alterar();

    printf("\nSelecione uma opcao e pressione ENTER: ");
    tratamento_numeroum(scan_alt, 0);

    switch (scan_alt[0])
    {
    case '1':
        alterar_funcionario();
        break;
    case '2':
        alterar_atleta();
        break;
    case '3':
        alterar_medico();
        break;
    case '4':
        alterar_local_treinamento();
        break;
    case '5':
        alterar_agendamento();
        break;
    case '6':
        altera_equipe();
        break;
    case '7':
        main_principal();
        break;
    case '8':
        tela_login();
        break;
    case '9':
        exit(0);
        break;
    default:
        printf("\n\nMenu inexistente, tente de 1 a 7.\n\n");
        system("pause");
        main_alterar();
    }

    printf("\n\n");
    getchar();
}

void main_delete(void)
{
    /*---- ACESSO AOS MENU DE CADASTRO E CONSULTA ----*/
    char scan_del[2];
    memset(scan_del, 0, sizeof(scan_del));

    /*Chama o menu de delete*/
    menu_delete();

    printf("\nSelecione uma opcao e pressione ENTER: ");
    tratamento_numeroum(scan_del, 0);

    switch (scan_del[0])
    {
    case '1':
        deletar_funcionario();
        break;
    case '2':
        deletar_atleta();
        break;
    case '3':
        deletar_medico();
        break;
    case '4':
        deletar_medico();
        break;
    case '5':
        deletar_local_();
        break;
    case '6':
        cancelar_agendamento();
        break;
    case '7':
        main_principal();
        break;
    case '8':
        tela_login();
        break;
        exit(0);
    default:
        printf("\n\nMenu inexistente, tente de 1 a 8.\n\n");
        system("pause");
        main_delete();
    }

    printf("\n\n");
    getchar();
}
/*-----------------------------------------------------------------------*/

/*MENU TELAS*/
void menu_principal(void)
{
    setlocale(LC_ALL, ""); //Para acentuação
    printf("\033[2J\033[1;1H");

    printf("          ========   CLIMANAGER   ========\n\n");

    printf("    .____________________________________________________.\n");
    printf("    |                                                    |\n");
    printf("    |                   Menu principal                   |\n");
    printf("    |____________________________________________________|\n");
    printf("    |                                                    |\n");
    printf("    |                                                    |\n");
    printf("    |       [1] - Menu de cadastros                      |\n");
    printf("    |       [2] - Menu de consultas                      |\n");
    printf("    |       [3] - Menu de alteracao                      |\n");
    printf("    |       [4] - Menu de delete                         |\n");
    printf("    |       [5] - Logout                                 |\n");
    printf("    |       [6] - Sair do Programa                       |\n");
    printf("    |                                                    |\n");
    printf("    |____________________________________________________|\n");
}

void menu_cadastros(void)
{
    setlocale(LC_ALL, ""); //Para acentuação
    printf("\033[2J\033[1;1H");

    printf("          ========   CLIMANAGER   ========\n\n");

    printf("    .____________________________________________________.\n");
    printf("    |                                                    |\n");
    printf("    |                   Menu de cadastros                |\n");
    printf("    |____________________________________________________|\n");
    printf("    |                                                    |\n");
    printf("    |                                                    |\n");
    printf("    |       [0] - Cadastros funcionario                  |\n");
    printf("    |       [1] - Cadastrar atletas                      |\n");
    printf("    |       [2] - Cadastrar medicos                      |\n");
    printf("    |       [3] - Cadastrar local de treinamento         |\n");
    printf("    |       [4] - Cadastrar agendamentos                 |\n");
    printf("    |       [5] - Cadastrar Equipes                      |\n");
    printf("    |       [6] - Cadastrar Pais                         |\n");
    printf("    |       [7] - Cadastrar Local                        |\n");
    printf("    |       [8] - Voltar ao menu principal               |\n");
    printf("    |       [9] - Logout                                 |\n");
    printf("    |                                                    |\n");
    printf("    |____________________________________________________|\n");
}

void menu_consultas(void)
{
    setlocale(LC_ALL, ""); //Para acentuação
    printf("\033[2J\033[1;1H");

    printf("          ========   CLIMANAGER   ========\n\n");

    printf("    .____________________________________________________.\n");
    printf("    |                                                    |\n");
    printf("    |                   Menu de consultas                |\n");
    printf("    |____________________________________________________|\n");
    printf("    |                                                    |\n");
    printf("    |                                                    |\n");
    printf("    |       [0] - Consultar funcionario                  |\n");
    printf("    |       [1] - Consultar atletas                      |\n");
    printf("    |       [2] - Consultar medicos                      |\n");
    printf("    |       [3] - Consultar Local de treinamento         |\n");
    printf("    |       [4] - Consultar agendamentos                 |\n");
    printf("    |       [5] - Consultar equipe                       |\n");
    printf("    |       [6] - Consultar Pais                         |\n");
    printf("    |       [7] - Consultar Local                        |\n");
    printf("    |       [8] - Voltar ao menu principal               |\n");
    printf("    |       [9] - Logout                                 |\n");
    printf("    |                                                    |\n");
    printf("    |____________________________________________________|\n");
}

void menu_alterar(void)
{
    setlocale(LC_ALL, ""); //Para acentuação
    printf("\033[2J\033[1;1H");

    printf("          ========   CLIMANAGER   ========\n\n");

    printf("    .____________________________________________________.\n");
    printf("    |                                                    |\n");
    printf("    |                   Menu de alteracao                |\n");
    printf("    |____________________________________________________|\n");
    printf("    |                                                    |\n");
    printf("    |                                                    |\n");
    printf("    |       [1] - Alterar agendamento                    |\n");
    printf("    |       [2] - Alterar atleta                         |\n");
    printf("    |       [3] - Alterar local de treinamento           |\n");
    printf("    |       [4] - Alterar medico                         |\n");
    printf("    |       [5] - Alterar equipe                         |\n");
    printf("    |       [5] - Alterar funcionarios                   |\n");
    printf("    |       [6] - Voltar ao menu principal               |\n");
    printf("    |       [7] - Logout                                 |\n");
    printf("    |                                                    |\n");
    printf("    |____________________________________________________|\n");
}

void menu_delete(void)
{
    setlocale(LC_ALL, ""); //Para acentuação
    printf("\033[2J\033[1;1H");

    printf("          ========   CLIMANAGER   ========\n\n");

    printf("    .____________________________________________________.\n");
    printf("    |                                                    |\n");
    printf("    |                   Menu de delete                     |\n");
    printf("    |____________________________________________________|\n");
    printf("    |                                                    |\n");
    printf("    |                                                    |\n");
    printf("    |       [1] - Cancelar Funcionario                   |\n");
    printf("    |       [2] - Deletar atleta                         |\n");
    printf("    |       [3] - Deletar medico                         |\n");
    printf("    |       [4] - Deletar local                          |\n");
    printf("    |       [5] - Deletar agendamento                         |\n");
    printf("    |       [6] - Voltar ao menu principal               |\n");
    printf("    |       [7] - Logout                                 |\n");
    printf("    |                                                    |\n");
    printf("    |____________________________________________________|\n");
}

/*CADASTRO TELAS*/
void cad_usuario(void)
{
    user cfuncionario = {'\0'};
    user_aux *cusuario_aux = calloc(1, sizeof(user_aux) * 1);

    int i, tam_msg;
    char crip_msg[52];

    /*Cadastro dos dados*/
    printf("\033[2J\033[1;1H");
    printf("CADASTRO DE FUNCIONARIOS\n\n");

    incrementa_id_func(&cfuncionario.codigo);
    cfuncionario.codigo++;

    printf("Codigo de cadastro: %i\n", cfuncionario.codigo);

    while (strcmp(cfuncionario.nome, "admin") != 0)
    {
        printf("\nNome do funcionario: \n");
        tratamento_desc50(cfuncionario.nome, 50);
        fseek(stdin, 0, SEEK_END);

        if (strcmp(cfuncionario.nome, "admin") == 0)
        {
            printf("\n\nNao e possível cadastrar o nome (admin), tente outro!\n\n");
            memset(cfuncionario.nome, 0, sizeof(cfuncionario.nome));
        }
        else
        {
            break;
        }
    }

    printf("\n\nCelular do funcionario: \n");
    tratamento_celular(cfuncionario.celular, 11);
    fseek(stdin, 0, SEEK_END);

    printf("\n\nE-mail do funcionario: \n");
    tratamento_desc50(cfuncionario.email, 50);
    fseek(stdin, 0, SEEK_END);

    /*CARREGAR OS DADOS DOS FUNCIONARIOS*/
    while (strcmp(cusuario_aux->cpf, cfuncionario.cpf) == 0 || *cfuncionario.cpf == '\0')
    {
        pfuncionario = fopen("dados\\cad_funcionario.txt", "r");
        if (pfuncionario == NULL)
        {
            fprintf(stderr, "\n\nErro ao abrir arquivo de funcionarios ou ainda não foi realizado nenhum cadastro!");

            char verificaarq[2];
            memset(verificaarq, 0, sizeof(verificaarq));

            printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
            tratamento_numeroum(verificaarq, 0);

            switch (verificaarq[0])
            {
            case '1':
                main_principal();
                break;
            case '2':
                exit(0);
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].");
                system("pause");
            }
        }

        while (strcmp(cusuario_aux->cpf, cfuncionario.cpf) == 0)
        {
            printf("\n\nCPF do funcionario: \n");
            tratamento_cpf(cfuncionario.cpf, 12);
            fseek(stdin, 0, SEEK_END);

            while (!feof(pfuncionario) && strcmp(cusuario_aux->cpf, cfuncionario.cpf) != 0)
            {
                fscanf(pfuncionario, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cusuario_aux->codigo, cusuario_aux->nome, cusuario_aux->celular, cusuario_aux->email, cusuario_aux->cpf, cusuario_aux->usuario, cusuario_aux->senha, cusuario_aux->endereco.estado, cusuario_aux->endereco.cidade, cusuario_aux->endereco.bairro, cusuario_aux->endereco.logradouro, cusuario_aux->endereco.complemento, cusuario_aux->endereco.cep);
            }
            if (strcmp(cusuario_aux->cpf, cfuncionario.cpf) == 0)
            {
                printf("\n\nJa existe um cadastro com esse CPF!\n");
            }
            else
            {
                break;
            }
        }
    }
    fclose(pfuncionario);

    while (strcmp(cfuncionario.usuario, "admin") != 0)
    {
        printf("\n\nUsuario para funcionario: \n");
        tratamento_desc50(cfuncionario.usuario, 50);
        fseek(stdin, 0, SEEK_END);

        if (strcmp(cfuncionario.usuario, "admin") == 0)
        {
            printf("\n\nNao e possível cadastrar o nome (admin), tente outro!\n\n");
            memset(cfuncionario.usuario, 0, sizeof(cfuncionario.usuario));
        }
        else if (strcmp(cfuncionario.usuario, cusuario_aux->usuario) == 0)
        {
            printf("\n\nEsse usuario ja esta cadastrado, tente outro!\n\n");
        }
        else
        {
            break;
        }
    }
    /* ---------- TRATAMENTO NO CAMPO SENHA ---------- */
    while (strcmp(cfuncionario.senha, cfuncionario.senha2) != 0 || strcmp(cfuncionario.senha, cfuncionario.senha2) == '\0')
    {
        printf("\n\nSenha do usuario: \n");
        tratamento_senha(cfuncionario.senha, 50);
        fseek(stdin, 0, SEEK_END);

        printf("\n\nDigite a senha novamente: \n");
        tratamento_senha(cfuncionario.senha2, 50);
        fseek(stdin, 0, SEEK_END);

        if (strcmp(cfuncionario.senha, cfuncionario.senha2) != 0)
        {
            memset(cfuncionario.senha, 0, sizeof(cfuncionario.senha));
            memset(cfuncionario.senha2, 0, sizeof(cfuncionario.senha2));
            printf("\nAs senhas não conferem, adicione senhas iguais!\n");
        }
        else
        {
            printf("\n--------- Localizacao --------- \n");

            printf("\n\nEstado do Usuario(XX): \n");
            tratamento_estado(cfuncionario.endereco.estado, 2);
            fseek(stdin, 0, SEEK_END);

            printf("\n\nCidade do Usuario: \n");
            tratamento_desc50(cfuncionario.endereco.cidade, 50);
            fseek(stdin, 0, SEEK_END);

            printf("\n\nBairro do Usuario: \n");
            tratamento_desc50(cfuncionario.endereco.bairro, 50);
            fseek(stdin, 0, SEEK_END);

            printf("\n\nLogradouro do Usuario: \n");
            tratamento_desc50(cfuncionario.endereco.logradouro, 50);
            fseek(stdin, 0, SEEK_END);

            printf("\n\nComplemento do Usuario: \n");
            tratamento_desc50(cfuncionario.endereco.complemento, 50);
            fseek(stdin, 0, SEEK_END);

            printf("\n\nCEP do Usuario: \n");
            tratamento_cep(cfuncionario.endereco.cep, 8);
            fseek(stdin, 0, SEEK_END);
        break;
        }
    }

    /*GRAVAR OS DADOS NO ARQUIVO DE TEXTO*/
    tam_msg = strlen(cfuncionario.senha);
    for (i = 0; i < tam_msg; i++)
    {
        crip_msg[i] = cfuncionario.senha[i] + 5;
    }
    crip_msg[tam_msg] = '\0';

    fclose(pfuncionario);
    pfuncionario = fopen("dados\\cad_funcionario.txt", "a+");
    if (pfuncionario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de funcionarios ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while (strcmp(cfuncionario.salvar, "1") != 0 || strcmp(cfuncionario.salvar, "2") != 0)
    {
        memset(cfuncionario.salvar, 0, sizeof(cfuncionario.salvar));

        printf("\n\nTecle [1] SALVAR esse cadastro ou [2] para CANCELAR este cadastro: ");
        tratamento_numeroum(cfuncionario.salvar, 0);
        fseek(stdin, 0, SEEK_END);

        switch (cfuncionario.salvar[0])
        {
        case '1':
            goto fim;
        case '2':
            main_cadastro();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }
fim:
    fprintf(pfuncionario, "%i\n", cfuncionario.codigo);
    fprintf(pfuncionario, "%s\n", cfuncionario.nome);
    fprintf(pfuncionario, "%s\n", cfuncionario.celular);
    fprintf(pfuncionario, "%s\n", cfuncionario.email);
    fprintf(pfuncionario, "%s\n", cfuncionario.cpf);
    fprintf(pfuncionario, "%s\n", cfuncionario.usuario);
    fprintf(pfuncionario, "%s\n", crip_msg);
    fprintf(pfuncionario, "%s\n", cfuncionario.endereco.estado);
    fprintf(pfuncionario, "%s\n", cfuncionario.endereco.cidade);
    fprintf(pfuncionario, "%s\n", cfuncionario.endereco.bairro);
    fprintf(pfuncionario, "%s\n", cfuncionario.endereco.logradouro);
    fprintf(pfuncionario, "%s\n", cfuncionario.endereco.complemento);
    fprintf(pfuncionario, "%s\n", cfuncionario.endereco.cep);
    fclose(pfuncionario);

    printf("\n\nUsuario cadastrado com sucesso! Tecle ENTER para voltar ao menu.");
    getchar();
    main_cadastro();
}

void cad_atleta(void)
{
    setlocale(LC_ALL, "Portuguese"); //Para acentuação

    system("mkdir dados");

    /*CRIAÇÃO DO ARQUIVO*/
    patleta = fopen("dados\\cad_atleta.txt", "a+");
    if (patleta == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de atletas ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }
    fclose(patleta);

    athlete cathlete = {'\0'};
    country *cpais = calloc(1, sizeof(cpais) * 1);
    athlete_aux *cathlete_aux = calloc(1, sizeof(athlete_aux) * 1);

    /*Cadastro dos dados*/
    printf("\033[2J\033[1;1H");
    printf("CADASTRO DE ATLETA\n\n");

    incrementa_id_atle(&cathlete.codigo);
    cathlete.codigo++;

    printf("Codigo de cadastro: %i\n", cathlete.codigo);

    printf("\n\nPais do Atleta: \n");
    tratamento_desc50(cathlete.pais, 50);
    fseek(stdin, 0, SEEK_END);

    printf("\nNome do Atleta: \n");
    tratamento_desc50(cathlete.nome, 50);
    fseek(stdin, 0, SEEK_END);

    /*CARREGAR OS DADOS DOS ATLETA*/
    patleta = fopen("dados\\cad_atleta.txt", "r");
    if (patleta == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de pacientes ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    {
        while (strcmp(cathlete_aux->nome, cathlete.nome) == 0 || *cathlete.nome == '\0')
    {
        while (strcmp(cathlete_aux->nome, cathlete.nome) == 0)
        {
            printf("\n\nNomo do Atleta: \n");
            tratamento_nome(cathlete.nome, 50);
            fseek(stdin, 0, SEEK_END);

            while (!feof(patleta) && strcmp(cathlete_aux->nome, cathlete.nome) != 0)
            {
                fscanf(patleta, "%d\n %[^\n] %[^\n]s", &cathlete_aux->codigo, cathlete_aux->nome, cathlete_aux->pais);
            }
            if (strcmp(cathlete_aux->nome, cathlete.nome) == 0)
            {
                printf("\n\nAtleta ja cadastrado!\n");
            }
            else
            {
                break;
            }
        }

        fclose(patleta);

        printf("\n\nAtleta cadastrado com sucesso! Tecle ENTER para voltar ao menu.");
        getchar();
        main_cadastro();

void cad_medico(void)
{
    setlocale(LC_ALL, "Portuguese"); //Para acentuação

    /*Ponteiros do metodo*/
    system("mkdir dados");

    /*CRIAÇÃO DO ARQUIVO*/
    pdoctor = fopen("dados\\cad_medico.txt", "a+");
    if (pdoctor == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de medicos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }
    fclose(pdoctor);

    doctor cmedico = {'\0'};
    country *cpais = calloc(1, sizeof(cpais) * 1);

    /*Cadastro dos dados*/
    printf("\033[2J\033[1;1H");
    printf("CADASTRO DE MEDICOS\n\n");

    incrementa_id_medi(&cmedico.codigo);
    cmedico.codigo++;

    printf("Codigo de cadastro: %i\n", cmedico.codigo);

    printf("\nNome do medico: \n");
    tratamento_desc50(cmedico.nome, 50);
    fseek(stdin, 0, SEEK_END);

    printf("\n\nCelular do medico: \n");
    tratamento_celular(cmedico.celular, 13);
    fseek(stdin, 0, SEEK_END);

    printf("\n\nE-mail do medico: \n");
    tratamento_desc50(cmedico.email, 50);
    fseek(stdin, 0, SEEK_END);

    printf("\n\nCPF ou similar do medico: \n");
    tratamento_cpf(cmedico.cpf, 12);
    fseek(stdin, 0, SEEK_END);

    printf("\n\nEspecialidade do medico: \n");
    tratamento_desc50(cmedico.especialidade, 50);
    fseek(stdin, 0, SEEK_END);

    /*-----------------------------------------------------------------------*/

    pdoctor = fopen("dados\\cad_medico.txt", "a+");
    if (pdoctor == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de medicos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while (strcmp(cmedico.salvar, "1") != 0 || strcmp(cmedico.salvar, "2") != 0)
    {
        memset(cmedico.salvar, 0, sizeof(cmedico.salvar));

        printf("\n\nTecle [1] SALVAR esse cadastro ou [2] para CANCELAR este cadastro: ");
        tratamento_numeroum(cmedico.salvar, 0);
        fseek(stdin, 0, SEEK_END);

        switch (cmedico.salvar[0])
        {
        case '1':
            goto fim;
        case '2':
            main_cadastro();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }
fim:

    fprintf(pdoctor, "%i\n", cmedico.codigo);
    fprintf(pdoctor, "%s\n", cmedico.nome);
    fprintf(pdoctor, "%s\n", cmedico.celular);
    fprintf(pdoctor, "%s\n", cmedico.email);
    fprintf(pdoctor, "%s\n", cmedico.cpf);
    fprintf(pdoctor, "%s\n", cmedico.especialidade);

    printf("\n\nMedico cadastrado com sucesso! Tecle ENTER para voltar ao menu.");
    getchar();
    main_cadastro();
}
void cad_agendamento(void)
{
    setlocale(LC_ALL, "Portuguese"); //Para acentuação

    /*Ponteiros do metodo*/
    system("mkdir dados");

    /*CRIAÇÃO DO ARQUIVO*/
    pagendamento = fopen("dados\\cad_agendamento.txt", "a+");
    if (pagendamento == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de agendamentos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }
    fclose(pagendamento);

    scheduling cagendamento = {'\0'};
    athlete *cathlete = calloc(1, sizeof(athlete) * 1);
    doctor *cmedico = calloc(1, sizeof(doctor) * 1);
    localtrein *clogradouro = calloc(1, sizeof(localtrein) * 1);
    scheduling_aux *agendamento_aux = calloc(1, sizeof(local_trein_aux) * 1);

    /*Cadastro dos dados*/
    printf("\033[2J\033[1;1H");
    printf("CADASTRO DE AGENDAMENTOS\n\n");

    incrementa_id_agen(&cagendamento.codigo);
    cagendamento.codigo++;

    printf("Codigo de cadastro: %i\n", cagendamento.codigo);

    /*-----------------------------------------------------------------------*/

    /*CARREGAR OS DADOS DOS atletas*/
    patleta = fopen("dados\\cad_atleta.txt", "r");
    if (patleta == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de pacientes ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while (strcmp(cathlete->nome, cagendamento.atleta.nome) != 0 || *cagendamento.atleta.nome== '\0')
    {
        printf("\nome do atleta: \n");
        tratamento_nome(cagendamento.atleta.nome, 50);
        fseek(stdin, 0, SEEK_END);

        while (!feof(patleta) && strcmp(cathlete->nome, cagendamento.atleta.nome) != 0)
        {
            fscanf(patleta, "%d\n %[^\n] %[^\n]s", &cathlete->codigo, cathlete->nome, cathlete->pais);
        }
        if (strcmp(cathlete->nome, cagendamento.atleta.nome) != 0)
        {
            printf("\n\nCPF Invalido!\n");
        }
        else
        {
            break;
        }
    }

    fclose(patleta);
    printf("\n\nNome do atleta: \n%s\n", cathlete->nome);

    /*-----------------------------------------------------------------------*/

    /*CARREGAR OS DADOS DOS MEDICOS*/
    pdoctor = fopen("dados\\cad_medico.txt", "r");
    if (pdoctor == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de medicas ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while (strcmp(cmedico->cpf, cagendamento.medico.cpf) != 0 || *cagendamento.medico.cpf == '\0')
    {
        printf("\nCPF do do Medico: \n");
        tratamento_cpf(cagendamento.medico.cpf, 12);
        fseek(stdin, 0, SEEK_END);

        while (!feof(pdoctor) && strcmp(cmedico->cpf, cagendamento.medico.cpf) != 0)
        {
            fscanf(pdoctor, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cmedico->codigo, cmedico->nome, cmedico->celular, cmedico->email, cmedico->cpf, cmedico->especialidade);
        }
        if (strcmp(cmedico->cpf, cagendamento.medico.cpf) != 0)
        {
            printf("\n\nCPF Invalido!\n");
        }
        else
        {
            break;
        }
    }

    fclose(pdoctor);
    printf("\n\nNome do medico: \n%s\n", cmedico->cpf);
    /*CARREGAR OS DADOS DOS AGENDAMENTOS*/
    pagendamento = fopen("dados\\cad_agendamento.txt", "r");
    if (pagendamento == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de agendamentos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while ((strcmp(agendamento_aux->hora, cagendamento.hora) == 0 && strcmp(agendamento_aux->data, cagendamento.data) == 0) || (*cagendamento.data == '\0' || *cagendamento.hora == '\0'))
    {
        memset(cagendamento.data, 0, sizeof(cagendamento.data));
        memset(cagendamento.hora, 0, sizeof(cagendamento.hora));

        printf("\nData do agendamento: \n");
        tratamento_tdta(cagendamento.data, 8);
        fseek(stdin, 0, SEEK_END);

        printf("\n\nHora do agendamento: \n");
        tratamento_hm(cagendamento.hora, 4);
        fseek(stdin, 0, SEEK_END);

        fscanf(pagendamento, "%d\n %[^\n] %[^\n] %[^\n] %[^\n]s", &agendamento_aux->codigo, agendamento_aux->medico.cpf, agendamento_aux->medico.nome, agendamento_aux->data, agendamento_aux->hora);

        if (strcmp(agendamento_aux->medico.cpf, cagendamento.medico.cpf) == 0 && strcmp(agendamento_aux->hora, cagendamento.hora) == 0 && strcmp(agendamento_aux->data, cagendamento.data) == 0)
        {
            printf("\n\nJa existe um agendamento com esse medico para esse horario, tente outro horario!\n");
        }
        else
        {
            break;
        }
    }

    fclose(pagendamento);

    /*-----------------------------------------------------------------------*/

    printf("\nDescricao do agendamento: \n");
    tratamento_desc50(cagendamento.descricao, 50);
    fseek(stdin, 0, SEEK_END);

    pagendamento = fopen("dados\\cad_agendamento.txt", "a+");
    if (pagendamento == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de agendamentos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while (strcmp(cagendamento.salvar, "1") != 0 || strcmp(cagendamento.salvar, "2") != 0)
    {
        memset(cagendamento.salvar, 0, sizeof(cagendamento.salvar));

        printf("\n\nTecle [1] SALVAR esse cadastro ou [2] para CANCELAR este cadastro: ");
        tratamento_numeroum(cagendamento.salvar, 0);
        fseek(stdin, 0, SEEK_END);

        switch (cagendamento.salvar[0])
        {
        case '1':
            goto fim;
        case '2':
            main_cadastro();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }
fim:

    fprintf(pagendamento, "%i\n", cagendamento.codigo);
    fprintf(pagendamento, "%s\n", cathlete->nome);
    fprintf(pagendamento, "%s\n", cathlete->pais);
    fprintf(pagendamento, "%s\n", cmedico->cpf);
    fprintf(pagendamento, "%s\n", cmedico->nome);
    fprintf(pagendamento, "%s\n", cagendamento.data);
    fprintf(pagendamento, "%s\n", cagendamento.hora);
    fprintf(pagendamento, "%s\n", cagendamento.descricao);
    fclose(pagendamento);

    printf("\n\nAgendamento realizado com sucesso! Tecle ENTER para voltar ao menu.");
    getchar();
    main_cadastro();
}

//consulta telas
int con_funcionario(void)
{
    pfuncionario = fopen("dados\\cad_funcionario.txt", "r");
    if (pfuncionario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de funcionarios ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    user *cusuario = calloc(1, sizeof(user) * 1);
    char scan[14];

    printf("\033[2J\033[1;1H");
    printf("CONSULTA DE USUARIOS DO SISTEMA\n\n");

    printf("Favor digite o cpf desejado: ");
    tratamento_cpf(scan, 12);
    fseek(stdin, 0, SEEK_END);

    while (!feof(pfuncionario) && strcmp(cusuario->cpf, scan) != 0)
    {
        fscanf(pfuncionario, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cusuario->codigo, cusuario->nome, cusuario->celular, cusuario->email, cusuario->cpf, cusuario->usuario, cusuario->senha, cusuario->endereco.estado, cusuario->endereco.cidade, cusuario->endereco.bairro, cusuario->endereco.logradouro, cusuario->endereco.complemento, cusuario->endereco.cep);
    }

    fclose(pfuncionario);
    if (strcmp(cusuario->cpf, scan) == 0)
    {
        memset(cusuario->senha, 0, sizeof(cusuario->senha));

        printf("\n\nCodigo: %i\nNome: %s\nCelular: %.2s-%.5s-%.4s\nE-mail: %s\nCPF: %.3s.%.3s.%.3s-%.2s\nUsuario no sistema: %s\nSenha: %s\nEstado: %s\nCidade: %s\nBairro: %s\nlogradouro: %s\nComplemento: %s\nCep: %.5s-%.3s\n", cusuario->codigo, cusuario->nome, cusuario->celular, cusuario->celular + 2, cusuario->celular + 7, cusuario->email, cusuario->cpf, cusuario->cpf + 3, cusuario->cpf + 6, cusuario->cpf + 9, cusuario->usuario, cusuario->senha, cusuario->endereco.estado, cusuario->endereco.cidade, cusuario->endereco.bairro, cusuario->endereco.logradouro, cusuario->endereco.complemento, cusuario->endereco.cep, cusuario->endereco.cep + 5);

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar um novo usuario: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(pfuncionario);
                con_funcionario();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    else
    {
        printf("\n\nCPF incorreto ou inexistente!\n");

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar um novo usuario: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(pfuncionario);
                con_funcionario();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    getchar();
    return 0;
    main_consulta();
}
int con_atleta(void)
{
    patleta = fopen("dados\\cad_atleta.txt", "r");
    if (patleta == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de pacientes ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    athlete *cathlete = calloc(1, sizeof(patleta) * 1);

    char scan[14];

    printf("\033[2J\033[1;1H");
    printf("CONSULTA DE ATLETA\n\n");

    printf("Favor digite o codigo desejado:");
    tratamento_cpf(scan, 12);
    fseek(stdin, 0, SEEK_END);

    while (!feof(patleta) && strcmp(cathlete->nome, scan) != 0)
    {
        fscanf(patleta, "%d\n %[^\n] %[^\n]s", cathlete->codigo, cathlete->nome, cathlete->pais);
    }

    fclose(patleta);
    if (strcmp(cathlete->nome, scan) == 0)
    {
        printf("%d\n\n codigo: %snNome: %s\pais:", cathlete->codigo, cathlete->nome, cathlete->pais);

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar um novo paciente: ");

            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(cathlete);
                con_atleta();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    else
    {
        printf("\n\nCPF incorreto ou inexistente!\n");

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar um novo paciente: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(cathlete);
                con_atleta();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    getchar();
    return 0;
    main_consulta();
}

int con_medico(void)
{
    pdoctor = fopen("dados\\cad_medico.txt", "r");
    if (pdoctor == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de medicos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    doctor *cmedico = calloc(1, sizeof(doctor) * 1);

    char scan[14];

    printf("\033[2J\033[1;1H");
    printf("CONSULTA DE MEDICOS\n\n");

    printf("Favor digite o CPF desejado:");
    tratamento_cpf(scan, 12);
    fseek(stdin, 0, SEEK_END);

    while (!feof(pdoctor) && strcmp(cmedico->cpf, scan) != 0)
    {
        fscanf(pdoctor, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cmedico->codigo, cmedico->nome, cmedico->celular, cmedico->email, cmedico->cpf, cmedico->especialidade);
    }

    fclose(pdoctor);
    if (strcmp(cmedico->cpf, scan) == 0)
    {
        printf("\n\nCodigo: %i\nNome: %s\nCelular: \nE-mail: %s\nCPF: \nEspecialidade: ", cmedico->codigo, cmedico->nome, cmedico->celular, cmedico->celular + 2, cmedico->celular + 7, cmedico->email, cmedico->cpf, cmedico->cpf + 3, cmedico->cpf + 6, cmedico->cpf + 9, cmedico->especialidade);

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar um novo medico: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(cmedico);
                con_medico();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    else
    {
        printf("\n\nCNPJ incorreto ou inexistente!\n");

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar um novo medico: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(cmedico);
                con_medico();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    getchar();
    return 0;
    main_consulta();
}

int con_filial(void)
{
    ptreint = fopen("dados\\cad_local_treinamento.txt", "r");
    if (ptreint == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de filial ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    localtrein *clocal = calloc(1, sizeof(localtrein) * 1);

    char scan[14];

    printf("\033[2J\033[1;1H");
    printf("CONSULTA DE Local de treinamento\n\n");

    printf("Favor digite o CP desejado:");
    tratamento_cnpj(scan, 15);
    fseek(stdin, 0, SEEK_END);

    while (!feof(ptreint) && strcmp(clocal->cp, scan) != 0)
    {
        fscanf(ptreint, "%hhd\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", clocal->logradouro, clocal->complemento, clocal->bairro, clocal->cidade, clocal->estado, clocal->cp);
    }

    fclose(ptreint);

    if (strcmp(clocal->cp, scan) == 0)
    {
        printf("%s\nlogradouro: %s\nComplemento: %s\nEstado: %s\nCp: %.5s-%.3s\n", clocal->logradouro, clocal->complemento, clocal->bairro, clocal->cidade, clocal->estado, clocal->cp);

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar uma nova filial: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(clocal);
                con_local_treinamento;
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    else
    {
        printf("\n\nCP incorreto ou inexistente!\n");

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar uma nova filial: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(clocal);
                con_local_treinamento();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    getchar();
    return 0;
    main_consulta();
}

int con_agendamento(void)
{
    pagendamento = fopen("dados\\cad_agendamento.txt", "r");
    if (pagendamento == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de agendamentos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    scheduling *cagendamento = calloc(1, sizeof(scheduling) * 1);
    scheduling_aux *cagendamento_aux = calloc(1, sizeof(scheduling_aux) * 1);

    char scan[12];
    memset(scan, 0, sizeof(scan));

    printf("\033[2J\033[1;1H");
    printf("CONSULTA DE AGENDAMENTOS\n\n");

    printf("Favor digite o Nome do atleta desejado:");
    tratamento_cpf(scan, 12);
    fseek(stdin, 0, SEEK_END);

    printf("\n\nData do agendamento: ");
    tratamento_tdtaqq(cagendamento_aux->data, 8);
    fseek(stdin, 0, SEEK_END);

    while (!feof(pagendamento) && (strcmp(cagendamento->atleta.nome, scan) != 0))
    {
        fscanf(pagendamento, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cagendamento->codigo, cagendamento->atleta.nome, cagendamento->medico.cpf, cagendamento->medico.nome, cagendamento->data, cagendamento->hora, cagendamento->descricao);
    }

    fclose(pagendamento);

    if ((strcmp(cagendamento->atleta.nome, scan) == 0))
    {
        printf("\n\nCodigo: \nNome do Atleta: \nCodigo do Atleta: %s\nCPF do medico: %.3s.%.3s.%.3s-%.2s\nNome do medico: %s\nData do agendamento: %.2s/%.2s/%.4s\nHora do Agendamento: %0.2f\nDescricao: %s\n", cagendamento->codigo, cagendamento->atleta.nome, cagendamento->atleta.codigo, cagendamento->medico.cpf, cagendamento->medico.cpf + 3, cagendamento->medico.cpf + 6, cagendamento->medico.cpf + 9, cagendamento->medico.nome, cagendamento->data, cagendamento->data + 2, cagendamento->data + 4, cagendamento->hora, cagendamento->hora + 2,  cagendamento->descricao);

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar uma nova agendamento: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(cagendamento);
                con_agendamento();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    else
    {
        printf("\n\nCPF incorreto ou inexistente!\n");

        char func_con[2];

        while((strcmp(func_con, "1") != 0) || (strcmp(func_con, "2") != 0))
        {
            memset(func_con, 0, sizeof(func_con));

            printf("\n\nTecle [1] para voltar ou [2] consultar uma nova agendamento: ");
            tratamento_numeroum(func_con, 0);

            switch (func_con[0])
            {
            case '1':
                main_consulta();
                break;
            case '2':
                free(cagendamento);
                con_agendamento();
                break;
            default:
                printf("\nMenu inexistente, tente novamente [1] ou [2].\n\n");
                system("pause");
            }
        }
    }
    getchar();
    return 0;
    main_consulta();
}
void alterar_usuario(void)
{
    int test;
    test = 0;

    user *cusuario = calloc(1, sizeof(user) * 1);
    user_upd *cusuario_upd = calloc(1, sizeof(user_upd) * 1);
    user_aux *cusuario_aux = calloc(1, sizeof(user_aux) * 1);

    pfuncionario = fopen("dados\\cad_funcionario.txt", "r");
    if (pfuncionario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de funcionarios ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_user_upd.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de temporario de alteração do usuario, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("ALTERAR USUARIO CADASTRADO\n\n");

    printf("Para alterar um usuario, insira o CPF do usuario: ");
    tratamento_cpf(cusuario_aux->cpf, 11);

    while (fscanf(pfuncionario, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cusuario->codigo, cusuario->nome, cusuario->celular, cusuario->email, cusuario->cpf, cusuario->usuario, cusuario->senha, cusuario->endereco.estado, cusuario->endereco.cidade, cusuario->endereco.bairro, cusuario->endereco.logradouro, cusuario->endereco.complemento, cusuario->endereco.cep) != EOF)
    {
        if (strcmp(cusuario->cpf, cusuario_aux->cpf) == 0)
        {
            retornaalteracao:
            test = 1;
            memset(cusuario->alterar, 0, sizeof(cusuario->alterar));

            printf("\n\n1.Nome\n2.Celular\n3.E-mail\n4.CPF\n5.Usuario\n6.Senha\n");
            mostrarendereco();
            tratamento_numero(cusuario->alterar, 2);

            /*NOME*/
            if (strcmp(cusuario->alterar, "1") == 0)
            {
                printf("\nNome do funcionario: \n");
                tratamento_desc50(cusuario_upd->nome, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario_upd->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
            }
            /*CELULAR*/
            else if (strcmp(cusuario->alterar, "2") == 0)
            {
                printf("\n\nCelular do funcionario: \n");
                tratamento_celular(cusuario_upd->celular, 11);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario_upd->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
            }
            /*E-MAIL*/
            else if (strcmp(cusuario->alterar, "3") == 0)
            {
                printf("\n\nE-mail do funcionario: \n");
                tratamento_desc50(cusuario_upd->email, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario_upd->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
            }
            /*CPF*/
            else if (strcmp(cusuario->alterar, "4") == 0)
            {
                printf("\n\nCPF do funcionario: \n");
                tratamento_cpf(cusuario_upd->cpf, 12);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario_upd->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
            }
            /*USUARIO*/
            else if (strcmp(cusuario->alterar, "5") == 0)
            {
                printf("\n\nUsuario para funcionario: \n");
                tratamento_desc50(cusuario_upd->usuario, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario_upd->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
            }
            /*SENHA*/
            else if (strcmp(cusuario->alterar, "6") == 0)
            {
                /* ---------- TRATAMENTO NO CAMPO SENHA ---------- */
                while (strcmp(cusuario_upd->senha, cusuario_upd->senha2) != 0 || strcmp(cusuario_upd->senha, cusuario_upd->senha2) == '\0')
                {
                    printf("\n\nSenha do usuario: \n");
                    tratamento_senha(cusuario_upd->senha, 50);
                    fseek(stdin, 0, SEEK_END);

                    printf("\n\nDigite a senha novamente: \n");
                    tratamento_senha(cusuario_upd->senha2, 50);
                    fseek(stdin, 0, SEEK_END);

                    if (strcmp(cusuario_upd->senha, cusuario_upd->senha2) != 0)
                    {
                        memset(cusuario_upd->senha, 0, sizeof(cusuario_upd->senha));
                        memset(cusuario_upd->senha2, 0, sizeof(cusuario_upd->senha2));
                        printf("\nAs senhas não conferem, adicione senhas iguais!\n");
                    }
                    else
                    {
                        int i = 0, tam_msg = 0;
                        char crip_msg[52];
                        /*GRAVAR OS DADOS NO ARQUIVO DE TEXTO*/
                        tam_msg = strlen(cusuario_upd->senha);
                        for (i = 0; i < tam_msg; i++)
                        {
                            crip_msg[i] = cusuario_upd->senha[i] + 5;
                        }
                        crip_msg[tam_msg] = '\0';

                        fprintf(temporario, "%i\n", cusuario->codigo);
                        fprintf(temporario, "%s\n", cusuario->nome);
                        fprintf(temporario, "%s\n", cusuario->celular);
                        fprintf(temporario, "%s\n", cusuario->email);
                        fprintf(temporario, "%s\n", cusuario->cpf);
                        fprintf(temporario, "%s\n", cusuario->usuario);
                        fprintf(temporario, "%s\n", crip_msg);
                        fprintf(temporario, "%s\n", cusuario->endereco.estado);
                        fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                        fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                        fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                        fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                        fprintf(temporario, "%s\n", cusuario->endereco.cep);
                        printf("\033[2J\033[1;1H");

                        break;
                    }
                }
            }
            /*ESTADO*/
            else if (strcmp(cusuario->alterar, "11") == 0)
            {
                printf("\n\nEstado do Usuario(XX): \n");
                tratamento_estado(cusuario_upd->endereco.estado, 2);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario_upd->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
                printf("\033[2J\033[1;1H");
            }
            /*CIDADE*/
            else if (strcmp(cusuario->alterar, "12") == 0)
            {
                printf("\n\nCidade do Usuario: \n");
                tratamento_desc50(cusuario_upd->endereco.cidade, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario_upd->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
                printf("\033[2J\033[1;1H");
            }
            /*BAIRRO*/
            else if (strcmp(cusuario->alterar, "13") == 0)
            {
                printf("\n\nBairro do Usuario: \n");
                tratamento_desc50(cusuario_upd->endereco.bairro, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario_upd->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
                printf("\033[2J\033[1;1H");
            }
            /*LOGRADOURO*/
            else if (strcmp(cusuario->alterar, "14") == 0)
            {
                printf("\n\nLogradouro do Usuario: \n");
                tratamento_desc50(cusuario_upd->endereco.logradouro, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario_upd->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
                printf("\033[2J\033[1;1H");
            }
            /*COMPLEMENTO*/
            else if (strcmp(cusuario->alterar, "15") == 0)
            {
                printf("\n\nComplemento do Usuario: \n");
                tratamento_desc50(cusuario_upd->endereco.complemento, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario_upd->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario->endereco.cep);
                printf("\033[2J\033[1;1H");
            }
            /*CEP*/
            else if (strcmp(cusuario->alterar, "16") == 0)
            {
                printf("\n\nCEP do Usuario: \n");
                tratamento_cep(cusuario_upd->endereco.cep, 8);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cusuario->codigo);
                fprintf(temporario, "%s\n", cusuario->nome);
                fprintf(temporario, "%s\n", cusuario->celular);
                fprintf(temporario, "%s\n", cusuario->email);
                fprintf(temporario, "%s\n", cusuario->cpf);
                fprintf(temporario, "%s\n", cusuario->usuario);
                fprintf(temporario, "%s\n", cusuario->senha);
                fprintf(temporario, "%s\n", cusuario->endereco.estado);
                fprintf(temporario, "%s\n", cusuario->endereco.cidade);
                fprintf(temporario, "%s\n", cusuario->endereco.bairro);
                fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
                fprintf(temporario, "%s\n", cusuario->endereco.complemento);
                fprintf(temporario, "%s\n", cusuario_upd->endereco.cep);
                printf("\033[2J\033[1;1H");
            }
            else
            {
                printf("\033[2J\033[1;1H");
                printf("\nATENCAO! Menu inexistente, tente um valor valido!");
                goto retornaalteracao;
            }
        }
        else
        {
            fprintf(temporario, "%i\n", cusuario->codigo);
            fprintf(temporario, "%s\n", cusuario->nome);
            fprintf(temporario, "%s\n", cusuario->celular);
            fprintf(temporario, "%s\n", cusuario->email);
            fprintf(temporario, "%s\n", cusuario->cpf);
            fprintf(temporario, "%s\n", cusuario->usuario);
            fprintf(temporario, "%s\n", cusuario->senha);
            fprintf(temporario, "%s\n", cusuario->endereco.estado);
            fprintf(temporario, "%s\n", cusuario->endereco.cidade);
            fprintf(temporario, "%s\n", cusuario->endereco.bairro);
            fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
            fprintf(temporario, "%s\n", cusuario->endereco.complemento);
            fprintf(temporario, "%s\n", cusuario->endereco.cep);
        }
    }

    fclose(temporario);
    fclose(pfuncionario);

    while ((strcmp(cusuario->salvar, "1") != 0 || strcmp(cusuario->salvar, "2") != 0) && test != 1)
    {
        printf("\n\n\nNao ha registros com esse CPF!\n\n");

        while((strcmp(cusuario->salvar, "1") != 0) || (strcmp(cusuario->salvar, "2") != 0))
        {
            memset(cusuario->salvar, 0, sizeof(cusuario->salvar));

            printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
            tratamento_numeroum(cusuario->salvar, 0);

            switch (cusuario->salvar[0])
            {
            case '1':
                alterar_usuario();
                break;
            case '2':
                main_alterar();
                break;
            default:
                printf("\n\nMenu inexistente, tente novamente [1] ou [2].\n");
                system("pause");
            }
        }
    }

    while ((strcmp(cusuario->salvar, "1") != 0 || strcmp(cusuario->salvar, "2") != 0))
    {
        memset(cusuario->salvar, 0, sizeof(cusuario->salvar));

        printf("\n\nTecle [1] para confirmar a ALTERACAO desse usuario ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cusuario->salvar, 0);

        if (strcmp(cusuario->salvar, "2") == 0)
        {
            remove("dados\\temp_user_upd.txt");
            break;
        }

        switch (cusuario->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_alterar();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\n\nMenu inexistente, tente novamente [1] ou [2].\n");
            system("pause");
        }

        if((strcmp(cusuario->salvar, "1") == 0 || strcmp(cusuario->salvar, "2") == 0))
        {
            int rem = 0;
            rem = remove("dados\\cad_funcionario.txt");
            if (rem == 0)
            {
                rename("dados\\temp_user_upd.txt", "dados\\cad_funcionario.txt");
                printf("\nAlteracao realizada!\n\n");
                break;
            }
            else
            {
                remove("dados\\temp_user_upd.txt");
                perror("não foi possível deletar o arquivo!");
                break;
            }
        }
    }

    system("pause");
    main_alterar();
}
void alterar_medico(void)
{
    int test;
    test = 0;

    doctor *cmedico = calloc(1, sizeof(doctor) * 1);
    doctor_upd *cmedico_upd = calloc(1, sizeof(doctor_upd) * 1);
    doctor_aux *cmedico_aux = calloc(1, sizeof(doctor_aux) * 1);

    pdoctor = fopen("dados\\cad_medico.txt", "r");
    if (pdoctor == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de medicos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_medico_upd.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de temporario de alteracao de medico, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("ALTERAR MEDICO CADASTRADO\n\n");

    printf("Para alterar um medico, insira o CPF do medico: ");
    tratamento_cpf(cmedico_aux->cpf, 11);

    while (fscanf(pdoctor, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cmedico->codigo, cmedico->nome, cmedico->celular, cmedico->email, cmedico->cpf, cmedico->especialidade) != EOF)
    {
        if (strcmp(cmedico->cpf, cmedico_aux->cpf) == 0)
        {
            retornaalteracao:
            test = 1;
            memset(cmedico->alterar, 0, sizeof(cmedico->alterar));

            printf("\n\n1.Nome\n2.Celular\n3.E-mail\n4.CPF\n5.Especialidade\n6.Filial de atuacao\n");
            mostrarendereco();
            tratamento_numero(cmedico->alterar, 2);

            /*NOME*/
            if (strcmp(cmedico->alterar, "1") == 0)
            {
                printf("\nNome do medico: \n");
                tratamento_desc50(cmedico_upd->nome, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cmedico->codigo);
                fprintf(temporario, "%s\n", cmedico_upd->nome);
                fprintf(temporario, "%s\n", cmedico->celular);
                fprintf(temporario, "%s\n", cmedico->email);
                fprintf(temporario, "%s\n", cmedico->cpf);
                fprintf(temporario, "%s\n", cmedico->especialidade);

            }
            /*CELULAR*/
            else if (strcmp(cmedico->alterar, "2") == 0)
            {
                printf("\n\nCelular do medico: \n");
                tratamento_celular(cmedico_upd->celular, 11);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cmedico->codigo);
                fprintf(temporario, "%s\n", cmedico->nome);
                fprintf(temporario, "%s\n", cmedico_upd->celular);
                fprintf(temporario, "%s\n", cmedico->email);
                fprintf(temporario, "%s\n", cmedico->cpf);
                fprintf(temporario, "%s\n", cmedico->especialidade);

            }
            /*E-MAIL*/
            else if (strcmp(cmedico->alterar, "3") == 0)
            {
                printf("\n\nE-mail do medico: \n");
                tratamento_desc50(cmedico_upd->email, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cmedico->codigo);
                fprintf(temporario, "%s\n", cmedico->nome);
                fprintf(temporario, "%s\n", cmedico->celular);
                fprintf(temporario, "%s\n", cmedico_upd->email);
                fprintf(temporario, "%s\n", cmedico->cpf);
                fprintf(temporario, "%s\n", cmedico->especialidade);

            }
            /*CPF*/
            else if (strcmp(cmedico->alterar, "4") == 0)
            {
                printf("\n\nCPF do medico: \n");
                tratamento_cpf(cmedico_upd->cpf, 12);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cmedico->codigo);
                fprintf(temporario, "%s\n", cmedico->nome);
                fprintf(temporario, "%s\n", cmedico->celular);
                fprintf(temporario, "%s\n", cmedico->email);
                fprintf(temporario, "%s\n", cmedico_upd->cpf);
                fprintf(temporario, "%s\n", cmedico->especialidade);

            }
            /*ESPECIALIDADE*/
            else if (strcmp(cmedico->alterar, "5") == 0)
            {
                printf("\n\nEspecialidade do medico: \n");
                tratamento_desc50(cmedico_upd->especialidade, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cmedico->codigo);
                fprintf(temporario, "%s\n", cmedico->nome);
                fprintf(temporario, "%s\n", cmedico->celular);
                fprintf(temporario, "%s\n", cmedico->email);
                fprintf(temporario, "%s\n", cmedico->cpf);
                fprintf(temporario, "%s\n", cmedico_upd->especialidade);

            }

    fclose(pdoctor);
    fclose(temporario);

    while ((strcmp(cmedico->salvar, "1") != 0 || strcmp(cmedico->salvar, "2") != 0) && test != 1)
    {
        printf("\n\n\nNao ha registros com esse CPF!\n\n");

        while((strcmp(cmedico->salvar, "1") != 0) || (strcmp(cmedico->salvar, "2") != 0))
        {
            printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
            tratamento_numeroum(cmedico->salvar, 0);

            switch (cmedico->salvar[0])
            {
            case '1':
                alterar_medico();
                break;
            case '2':
                main_alterar();
                break;
            default:
                printf("\n\nMenu inexistente, tente novamente [1] ou [2].\n");
                system("pause");
            }
        }
    }

    while ((strcmp(cmedico->salvar, "1") != 0 || strcmp(cmedico->salvar, "2") != 0))
    {
        memset(cmedico->salvar, 0, sizeof(cmedico->salvar));

        printf("\n\nTecle [1] para confirmar a ALTERACAO desse medico ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cmedico->salvar, 0);

        if (strcmp(cmedico->salvar, "2") == 0)
        {
            remove("dados\\temp_medico_upd.txt");
            break;
        }

        switch (cmedico->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_alterar();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\n\nMenu inexistente, tente novamente [1] ou [2].\n");
            system("pause");
        }

        if((strcmp(cmedico->salvar, "1") == 0 || strcmp(cmedico->salvar, "2") == 0))
        {
            int rem = 0;
            rem = remove("dados\\cad_medico.txt");
            if (rem == 0)
            {
                rename("dados\\temp_medico_upd.txt", "dados\\cad_medico.txt");
                printf("\nAlteracao realizada!\n\n");
                break;
            }
            else
            {
                remove("dados\\temp_medico_upd.txt");
                perror("não foi possível deletar o arquivo!");
                break;
            }
        }
    }
    system("pause");
    main_alterar();
}
void alterar_agendamento(void)
{
    int test;
    test = 0;

    scheduling *cagendamento = calloc(1, sizeof(scheduling) * 1);
    scheduling_upd *cagendamento_upd = calloc(1, sizeof(scheduling_upd) * 1);
    scheduling_aux *cagendamento_aux = calloc(1, sizeof(scheduling_aux) * 1);

    pagendamento = fopen("dados\\cad_agendamento.txt", "r");
    if (pagendamento == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de agendamentos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_agendamento_upd.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de temporario de alteracao de agendamentos, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("ALTERAR AGENDAMENTO CADASTRADO\n\n");

    printf("Insira o nome do atleta: ");
    tratamento_cpf(cagendamento_aux->atleta.nome, 11);
    fseek(stdin, 0, SEEK_END);

    printf("\n\nData do agendamento: ");
    tratamento_tdtaqq(cagendamento_aux->data, 8);
    fseek(stdin, 0, SEEK_END);

    while (fscanf(pagendamento, "%d\n %d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cagendamento->codigo, &cagendamento->atleta.codigo, cagendamento->atleta.nome, cagendamento->medico.cpf, cagendamento->medico.nome, cagendamento->data, cagendamento->hora, cagendamento->descricao) != EOF)
    {
        if ((strcmp(cagendamento->atleta.nome, cagendamento_aux->atleta.nome) == 0) && (strcmp(cagendamento->data, cagendamento_aux->data) == 0))
        {
            retornaalteracao:
            test = 1;
            memset(cagendamento->alterar, 0, sizeof(cagendamento->alterar));

            printf("\n\n1.CPF do paciente\n2.CPF do medico\n3.Filial de consulta\n4.Data da consulta\n5.Hora da consulta\n6.Valor da consulta\n7.Descricao da consulta\n\nEscolha qual informacao voce deseja alterar e tecle ENTER: \n");
            tratamento_numero(cagendamento->alterar, 2);

            /*CPF DO PACIENTE*/
            if (strcmp(cagendamento->alterar, "1") == 0)
            {
                printf("\nCPF do paciente: \n");
                tratamento_cpf(cagendamento_upd->atleta.nome, 12);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cagendamento->codigo);
                fprintf(temporario, "%d\n", cagendamento_upd->atleta.codigo);
                fprintf(temporario, "%s\n", cagendamento->atleta.nome);
                fprintf(temporario, "%s\n", cagendamento->medico.cpf);
                fprintf(temporario, "%s\n", cagendamento->medico.nome);
                fprintf(temporario, "%s\n", cagendamento->data);
                fprintf(temporario, "%s\n", cagendamento->hora);
                fprintf(temporario, "%s\n", cagendamento->descricao);
            }
            /*CPF DO MEDICO*/
            else if (strcmp(cagendamento->alterar, "2") == 0)
            {
                printf("\nCPF do do Medico: \n");
                tratamento_cpf(cagendamento_upd->medico.cpf, 12);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cagendamento->codigo);
                fprintf(temporario, "%d\n", cagendamento->atleta.codigo);
                fprintf(temporario, "%s\n", cagendamento->atleta.nome);
                fprintf(temporario, "%s\n", cagendamento_upd->medico.cpf);
                fprintf(temporario, "%s\n", cagendamento->medico.nome);
                fprintf(temporario, "%s\n", cagendamento->data);
                fprintf(temporario, "%s\n", cagendamento->hora);
                fprintf(temporario, "%s\n", cagendamento->descricao);
            }

            /*DATA*/
            else if (strcmp(cagendamento->alterar, "4") == 0)
            {
                printf("\nData do agendamento: \n");
                tratamento_tdta(cagendamento_upd->data, 8);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cagendamento->codigo);
                fprintf(temporario, "%d\n", cagendamento->atleta.codigo);
                fprintf(temporario, "%s\n", cagendamento->atleta.nome);
                fprintf(temporario, "%s\n", cagendamento->medico.cpf);
                fprintf(temporario, "%s\n", cagendamento->medico.nome);
                fprintf(temporario, "%s\n", cagendamento_upd->data);
                fprintf(temporario, "%s\n", cagendamento->hora);
                fprintf(temporario, "%s\n", cagendamento->descricao);
            }
            /*HORA*/
            else if (strcmp(cagendamento->alterar, "5") == 0)
            {
                printf("\n\nHora do agendamento: \n");
                tratamento_hm(cagendamento_upd->hora, 4);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cagendamento->codigo);
                fprintf(temporario, "%d\n", cagendamento->atleta.codigo);
                fprintf(temporario, "%s\n", cagendamento->atleta.nome);
                fprintf(temporario, "%s\n", cagendamento->medico.cpf);
                fprintf(temporario, "%s\n", cagendamento->medico.nome);
                fprintf(temporario, "%s\n", cagendamento->data);
                fprintf(temporario, "%s\n", cagendamento_upd->hora);
                fprintf(temporario, "%s\n", cagendamento->descricao);
            }
            /*DESCRICAO*/
            else if (strcmp(cagendamento->alterar, "7") == 0)
            {
                printf("\nDescricao do agendamento: \n");
                tratamento_desc50(cagendamento_upd->descricao, 50);
                fseek(stdin, 0, SEEK_END);
                fprintf(temporario, "%i\n", cagendamento->codigo);
                fprintf(temporario, "%d\n", cagendamento->atleta.codigo);
                fprintf(temporario, "%s\n", cagendamento->atleta.nome);
                fprintf(temporario, "%s\n", cagendamento->medico.cpf);
                fprintf(temporario, "%s\n", cagendamento->medico.nome);
                fprintf(temporario, "%s\n", cagendamento->data);
                fprintf(temporario, "%s\n", cagendamento->hora);
                fprintf(temporario, "%s\n", cagendamento_upd->descricao);
            }
            /*VALOR não CORRESPONDE AO MENU*/
            else
            {
                printf("\033[2J\033[1;1H");
                printf("\nATENCAO! Menu inexistente, tente um valor valido!");
                goto retornaalteracao;
            }
        }
        else
        {
            fprintf(temporario, "%i\n", cagendamento->codigo);
            fprintf(temporario, "%d\n", cagendamento->atleta.codigo);
            fprintf(temporario, "%s\n", cagendamento->atleta.nome);
            fprintf(temporario, "%s\n", cagendamento->medico.cpf);
            fprintf(temporario, "%s\n", cagendamento->medico.nome);
            fprintf(temporario, "%s\n", cagendamento->data);
            fprintf(temporario, "%s\n", cagendamento->hora);
            fprintf(temporario, "%s\n", cagendamento->descricao);
        }
    }

    fclose(pagendamento);
    fclose(temporario);

    while ((strcmp(cagendamento->salvar, "1") != 0 || strcmp(cagendamento->salvar, "2") != 0) && test != 1)
    {
        printf("\n\n\nNao ha registros com esses dados cadastrados!\n\n");

        while((strcmp(cagendamento->salvar, "1") != 0) || (strcmp(cagendamento->salvar, "2") != 0))
        {
            printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
            tratamento_numeroum(cagendamento->salvar, 0);

            switch (cagendamento->salvar[0])
            {
            case '1':
                alterar_agendamento();
                break;
            case '2':
                main_alterar();
                break;
            default:
                printf("\n\nMenu inexistente, tente novamente [1] ou [2].\n");
                system("pause");
            }
        }
    }

    while ((strcmp(cagendamento->salvar, "1") != 0 || strcmp(cagendamento->salvar, "2") != 0))
    {
        memset(cagendamento->salvar, 0, sizeof(cagendamento->salvar));

        printf("\n\nTecle [1] para confirmar a ALTERACAO desse agendamento ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cagendamento->salvar, 0);

        if (strcmp(cagendamento->salvar, "2") == 0)
        {
            remove("dados\\temp_agendamento_upd.txt");
            break;
        }

        switch (cagendamento->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_alterar();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\n\nMenu inexistente, tente novamente [1] ou [2].\n");
            system("pause");
        }

        if((strcmp(cagendamento->salvar, "1") == 0 || strcmp(cagendamento->salvar, "2") == 0))
        {
            int rem = 0;
            rem = remove("dados\\cad_agendamento.txt");
            if (rem == 0)
            {
                rename("dados\\temp_agendamento_upd.txt", "dados\\cad_agendamento.txt");
                printf("\nAlteracao realizada!\n\n");
                break;
            }
            else
            {
                remove("dados\\temp_agendamento_upd.txt");
                perror("não foi possível deletar o arquivo!");
                break;
            }
        }
    }
    system("pause");
    main_alterar();
}
/*DELETE TELAS*/
void deletar_usuario(void)
{
    int test;
    test = 0;

    user *cusuario = calloc(1, sizeof(user) * 1);
    user_del *cusuario_del = calloc(1, sizeof(user_del) * 1);

    pfuncionario = fopen("dados\\cad_funcionario.txt", "r");
    if (pfuncionario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de funcionarios ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_user_del.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao excluir arquivo de temporario  de funcionarios, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("DELETAR USUARIO CADASTRADO\n\n");

    printf("Para deletar um usuario, insira o CPF do usuario: ");
    tratamento_cpf(cusuario_del->cpf, 11);

    while (fscanf(pfuncionario, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cusuario->codigo, cusuario->nome, cusuario->celular, cusuario->email, cusuario->cpf, cusuario->usuario, cusuario->senha, cusuario->endereco.estado, cusuario->endereco.cidade, cusuario->endereco.bairro, cusuario->endereco.logradouro, cusuario->endereco.complemento, cusuario->endereco.cep) != EOF)
    {
        if (strcmp(cusuario->cpf, cusuario_del->cpf) != 0)
        {
            fprintf(temporario, "%i\n", cusuario->codigo);
            fprintf(temporario, "%s\n", cusuario->nome);
            fprintf(temporario, "%s\n", cusuario->celular);
            fprintf(temporario, "%s\n", cusuario->email);
            fprintf(temporario, "%s\n", cusuario->cpf);
            fprintf(temporario, "%s\n", cusuario->usuario);
            fprintf(temporario, "%s\n", cusuario->senha);
            fprintf(temporario, "%s\n", cusuario->endereco.estado);
            fprintf(temporario, "%s\n", cusuario->endereco.cidade);
            fprintf(temporario, "%s\n", cusuario->endereco.bairro);
            fprintf(temporario, "%s\n", cusuario->endereco.logradouro);
            fprintf(temporario, "%s\n", cusuario->endereco.complemento);
            fprintf(temporario, "%s\n", cusuario->endereco.cep);
        }
        else
        {
            test++;
            memset(cusuario->senha, 0, sizeof(cusuario->senha));
            printf("\n\nCodigo: %i\nNome: %s\nCelular: %.2s-%.5s-%.4s\nE-mail: %s\nCPF: %.3s.%.3s.%.3s-%.2s\nUsuario no sistema: %s\nSenha: %s\nEstado: %s\nCidade: %s\nBairro: %s\nlogradouro: %s\nComplemento: %s\nCep: %.5s-%.3s\n", cusuario->codigo, cusuario->nome, cusuario->celular, cusuario->celular + 2, cusuario->celular + 7, cusuario->email, cusuario->cpf, cusuario->cpf + 3, cusuario->cpf + 6, cusuario->cpf + 9, cusuario->usuario, cusuario->senha, cusuario->endereco.estado, cusuario->endereco.cidade, cusuario->endereco.bairro, cusuario->endereco.logradouro, cusuario->endereco.complemento, cusuario->endereco.cep, cusuario->endereco.cep + 5);
        }
    }

    fclose(pfuncionario);
    fclose(temporario);

    while ((strcmp(cusuario->salvar, "1") != 0 || strcmp(cusuario->salvar, "2") != 0) && test == 0)
    {
        printf("\n\n\nNao ha registros com esse CPF!\n\n");

        memset(cusuario->salvar, 0, sizeof(cusuario->salvar));

        printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cusuario->salvar, 0);

        switch (cusuario->salvar[0])
        {
        case '1':
            deletar_usuario();
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while ((strcmp(cusuario->salvar, "1") != 0 || strcmp(cusuario->salvar, "2") != 0))
    {
        memset(cusuario->salvar, 0, sizeof(cusuario->salvar));

        printf("\n\nTecle [1] para confirmar a EXCLUSAO desse usuario ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cusuario->salvar, 0);

        if (strcmp(cusuario->salvar, "2") == 0)
        {
            remove("dados\\temp_user_del.txt");
            break;
        }

        switch (cusuario->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }

        if((strcmp(cusuario->salvar, "1") == 0 || strcmp(cusuario->salvar, "2") == 0))
        {
            int rem = 0;
            rem = remove("dados\\cad_funcionario.txt");
            if (rem == 0)
            {
                rename("dados\\temp_user_del.txt", "dados\\cad_funcionario.txt");
                printf("\nO arquivo foi deletado com sucesso!\n");
                break;
            }
            else
            {
                remove("dados\\temp_user_del.txt");
                perror("não foi possível deletar o arquivo!");
                break;
            }
        }
    }
    system("pause");
    main_delete();
}
void deletar_paciente(void)
{
    int test;
    test = 0;

    athlete_del *cathlete = calloc(1, sizeof(patleta) * 1);
    athlete_del *cathlete_del = calloc(1, sizeof(athlete_del) * 1);

    patleta = fopen("dados\\cad_atleta.txt", "r");
    if (patleta == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de pacientes ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_paciente_del.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao excluir arquivo de temporario de pacientes, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("DELETAR PACIENTE CADASTRADO\n\n");

    printf("Para deletar um registro, insira o nome do atleta: ");
    tratamento_nome(cathlete_del->nome, 50);

    while (fscanf(patleta, "%d\n %[^\n] %[^\n] %[^\n]s", &cathlete->codigo, cathlete->nome, cathlete->pais) != EOF)
    {
        if (strcmp(cathlete->nome, cathlete_del->nome) != 0)
        {
            fprintf(temporario, "%i\n", cathlete->codigo);
            fprintf(temporario, "%s\n", cathlete->nome);
            fprintf(temporario, "%s\n", cathlete->pais);
        }
        else
        {
            test++;
            printf("\n\nCodigo: %i\nNome: \pais: : \n", &cathlete->codigo, cathlete->nome, cathlete->pais);
        }
    }

    fclose(patleta);
    fclose(temporario);

    while ((strcmp(cathlete->salvar, "1") != 0 || strcmp(cathlete->salvar, "2") != 0) && test == 0)
    {
        printf("\n\n\nNao ha registros com esse nome!\n\n");

        memset(cathlete->salvar, 0, sizeof(cathlete->salvar));

        printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cathlete->salvar, 0);

        switch (cathlete->salvar[0])
        {
        case '1':
            deletar_atleta();
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while ((strcmp(cathlete->salvar, "1") != 0 || strcmp(cathlete->salvar, "2") != 0))
    {
        memset(cathlete->salvar, 0, sizeof(cathlete->salvar));

        printf("\n\nTecle [1] para confirmar a EXCLUSAO desse atleta ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cathlete->salvar, 0);

        if (strcmp(cathlete->salvar, "2") == 0)
        {
            remove("dados\\temp_atleta_del.txt");
            break;
        }

        switch (cathlete->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }

        if((strcmp(cathlete->salvar, "1") == 0 || strcmp(cathlete->salvar, "2") == 0))
        {
            int rem = 0;
            rem = remove("dados\\cad_atleta.txt");
            if (rem == 0)
            {
                rename("dados\\temp_atleta_del_del.txt", "dados\\cad_atleta.txt");
                printf("\nO arquivo foi deletado com sucesso!\n");
                break;
            }
            else
            {
                remove("dados\\temp_atleta_del_del.txt");
                perror("não foi possível deletar o arquivo!");
                break;
            }
        }
    }
    system("pause");
    main_delete();
}

void deletar_medico(void)
{
    int test;
    test = 0;

    doctor *cmedico = calloc(1, sizeof(doctor) * 1);
    doctor_del *cmedico_del = calloc(1, sizeof(doctor_del) * 1);

    pdoctor = fopen("dados\\cad_medico.txt", "r");
    if (pdoctor == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de medicos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_medico_del.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao excluir arquivo de temporario de medicos, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("DELETAR MEDICO CADASTRADO\n\n");

    printf("Para deletar um registro, insira o CPF do medico: ");
    tratamento_cpf(cmedico_del->cpf, 11);

    while (fscanf(pdoctor, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &cmedico->codigo, cmedico->nome, cmedico->celular, cmedico->email, cmedico->cpf, cmedico->especialidade) != EOF)
    {
        if (strcmp(cmedico->cpf, cmedico_del->cpf) != 0)
        {
            fprintf(temporario, "%i\n", cmedico->codigo);
            fprintf(temporario, "%s\n", cmedico->nome);
            fprintf(temporario, "%s\n", cmedico->celular);
            fprintf(temporario, "%s\n", cmedico->email);
            fprintf(temporario, "%s\n", cmedico->cpf);
            fprintf(temporario, "%s\n", cmedico->especialidade);

        }
        else
        {
            test++;
            printf("\n\nCodigo: %i\nNome: %s\nCelular: %.2s-%.5s-%.4s\nE-mail: %s\nCPF: %.3s.%.3s.%.3s-%.2s\nEspecialidade: \n", cmedico->codigo, cmedico->nome, cmedico->celular, cmedico->celular + 2, cmedico->celular + 7, cmedico->email, cmedico->cpf, cmedico->cpf + 3, cmedico->cpf + 6, cmedico->cpf + 9, cmedico->especialidade);
        }
    }

    fclose(pdoctor);
    fclose(temporario);

    while ((strcmp(cmedico->salvar, "1") != 0 || strcmp(cmedico->salvar, "2") != 0) && test == 0)
    {
        printf("\n\n\nNao ha registros com esse CPF!\n\n");

        memset(cmedico->salvar, 0, sizeof(cmedico->salvar));

        printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cmedico->salvar, 0);

        switch (cmedico->salvar[0])
        {
        case '1':
            deletar_medico();
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while ((strcmp(cmedico->salvar, "1") != 0 || strcmp(cmedico->salvar, "2") != 0))
    {
        memset(cmedico->salvar, 0, sizeof(cmedico->salvar));

        printf("\n\nTecle [1] para confirmar a EXCLUSAO desse medico ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cmedico->salvar, 0);

        if (strcmp(cmedico->salvar, "2") == 0)
        {
            remove("dados\\temp_medico_del.txt");
            break;
        }

        switch (cmedico->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }

        if((strcmp(cmedico->salvar, "1") == 0 || strcmp(cmedico->salvar, "2") == 0))
        {
            int rem = 0;
            rem = remove("dados\\cad_medico.txt");
            if (rem == 0)
            {
                printf("\nO arquivo foi deletado com sucesso!\n");
                rename("dados\\temp_medico_del.txt", "dados\\cad_medico.txt");
                break;
            }
            else
            {
                remove("dados\\temp_medico_del.txt");
                perror("não foi possível deletar o arquivo!");
                break;
            }
        }
    }
    system("pause");
    main_delete();
}
void deletar_local_treinamento(void)
{
    int test;
    test = 0;

    localtrein *clocal = calloc(1, sizeof(localtrein) * 1);
    local_trein_del *localtrein_del = calloc(1, sizeof(localtrein_del) * 1);

    ptreint = fopen("dados\\cad_local_treinamento.txt", "r");
    if (ptreint == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de Lacal de treinamento ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_localdetreinamento_del.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao excluir arquivo de temporario de filial, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("DELETAR LOCAL DE TREINAMENTO CADASTRADO\n\n");

    printf("Para deletar um registro, insira o CP da filial: ");
    tratamento_codigo(localtrein_del->cp, 15);

    while (fscanf(ptreint, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", localtrein_del->logradouro, localtrein_del->complemento, localtrein_del->bairro, localtrein_del->cidade, localtrein_del->estado, localtrein_del->cp) != EOF)
    {
        if (strcmp(localtrein_del ->cp, localtrein_del->cp) != 0)
        {
            fprintf(temporario, "%s\n", localtrein_del->logradouro);
            fprintf(temporario, "%s\n", localtrein_del->complemento);
            fprintf(temporario, "%s\n", localtrein_del->bairro);
            fprintf(temporario, "%s\n", localtrein_del->cidade);
            fprintf(temporario, "%s\n", localtrein_del->estado);
            fprintf(temporario, "%s\n", localtrein_del->cp);

        }
        else
        {
            test++;
            printf("\n\nLogradouro: %i\nComplemento: %s\nBairro: \ncidade: %s\nEstado: %s\nCidade: %s\nestado: %s\nCP: \n", localtrein_del->logradouro, localtrein_del->complemento, localtrein_del->bairro, localtrein_del->cidade, localtrein_del->estado, localtrein_del->cp);
    }

    fclose(ptreint);
    fclose(temporario);

    while ((strcmp(clocal->salvar, "1") != 0 || strcmp(clocal->salvar, "2") != 0) && test == 0)
    {
        printf("\n\n\nNao ha registros com esse CNPJ!\n\n");

        memset(clocal->salvar, 0, sizeof(clocal->salvar));

        printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(clocal->salvar, 0);

        switch (clocal->salvar[0])
        {
        case '1':
            deletar_local_treinamento();
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while ((strcmp(clocal->salvar, "1") != 0 || strcmp(clocal->salvar, "2") != 0))
    {
        memset(clocal->salvar, 0, sizeof(clocal->salvar));

        printf("\n\nTecle [1] para confirmar a EXCLUSAO desse filial ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(clocal->salvar, 0);

        if (strcmp(clocal->salvar, "2") == 0)
        {
            remove("dados\\temp_localtrein_del.txt");
            break;
        }

        switch (clocal->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }

        if((strcmp(clocal->salvar, "1") == 0 || strcmp(clocal->salvar, "2") == 0))
        {
            int rem = 0;
            rem = remove("dados\\cad_local_treinamento.txt");
            if (rem == 0)
            {
                printf("\nO arquivo foi deletado com sucesso!\n");
                rename("dados\\temp_localtrein_del.txt", "dados\\cad_filial.txt");
                break;
            }
            else
            {
                remove("dados\\temp_localtrein_del.txt");
                perror("não foi possível deletar o arquivo!");
                break;
            }
        }
    }
    system("pause");
    main_delete();
}
void cancelar_agendamento(void)
{
    int test;
    test = 0;

    scheduling *cagendamento = calloc(1, sizeof(scheduling) * 1);
    scheduling_del *cagendamento_del = calloc(1, sizeof(scheduling_del) * 1);
    scheduling_aux *cagendamento_aux = calloc(1, sizeof(scheduling_aux) * 1);

    pagendamento = fopen("dados\\cad_agendamento.txt", "r");
    if (pagendamento == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de agendamentos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    temporario = fopen("dados\\temp_agendamento_del.txt", "w");
    if (temporario == NULL)
    {
        fprintf(stderr, "\n\nErro ao excluir arquivo de temporario de agendamentos, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    printf("\033[2J\033[1;1H");
    printf("CANCELAR AGENDAMENTOS\n\n");

    printf("Insira o Nome do atleta: ");
    tratamento_cpf(cagendamento_del->atleta.nome, 11);

    printf("\n\nData do agendamento: ");
    tratamento_tdtaqq(cagendamento_aux->data, 8);

    while (fscanf(pagendamento, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %f\n %[^\n]s", &cagendamento->codigo, cagendamento->atleta.codigo, cagendamento->atleta.nome, cagendamento->medico.cpf, cagendamento->medico.nome, cagendamento->data, cagendamento->hora, cagendamento->descricao) != EOF)
    {
        if ((strcmp(cagendamento->atleta.codigo, cagendamento_del->atleta.codigo) != 0 && strcmp(cagendamento->data, cagendamento_aux->data) != 0) || (strcmp(cagendamento->atleta.codigo, cagendamento_del->atleta.codigo) == 0 && strcmp(cagendamento->data, cagendamento_aux->data) != 0) || (strcmp(cagendamento->atleta.codigo, cagendamento_del->atleta.codigo) != 0 && strcmp(cagendamento->data, cagendamento_aux->data) == 0))
        {
            fprintf(temporario, "%i\n", cagendamento->codigo);
            fprintf(temporario, "%s\n", cagendamento->atleta.codigo);
            fprintf(temporario, "%s\n", cagendamento->atleta.nome);
            fprintf(temporario, "%s\n", cagendamento->medico.cpf);
            fprintf(temporario, "%s\n", cagendamento->medico.nome);
            fprintf(temporario, "%s\n", cagendamento->data);
            fprintf(temporario, "%s\n", cagendamento->hora);
            fprintf(temporario, "%s\n", cagendamento->descricao);
        }
        else if ((strcmp(cagendamento->atleta.codigo, cagendamento_del->atleta.codigo) == 0 && strcmp(cagendamento->data, cagendamento_aux->data) == 0))
        {
            test++;
            printf("\n\nCodigo: %i\nCodigo do atleta: \nNome do atleta: %s\nCPF do medico: %.3s.%.3s.%.3s-%.2s\nNome do medico: %s\nCNPJ da filial: %.2s.%.3s.%.3s/%.4s-%.2s\nNome da Filial: %s\nData do agendamento: %.2s/%.2s/%.4s\nHora do Agendamento: %.2s:%.2s\nValor da consulta: %0.2f\nDescricao: %s\n", cagendamento->codigo, cagendamento->atleta.codigo, cagendamento->atleta.nome, cagendamento->medico.cpf, cagendamento->medico.cpf + 3, cagendamento->medico.cpf + 6, cagendamento->medico.cpf + 9, cagendamento->medico.nome, cagendamento->data, cagendamento->data + 2, cagendamento->data + 4, cagendamento->hora, cagendamento->hora + 2, cagendamento->descricao);
        }
    }

    fclose(pagendamento);
    fclose(temporario);

    while ((strcmp(cagendamento->salvar, "1") != 0 || strcmp(cagendamento->salvar, "2") != 0) && test == 0)
    {
        printf("\n\n\nNao ha registros com esse CPF!\n\n");

        memset(cagendamento->salvar, 0, sizeof(cagendamento->salvar));

        printf("\n\nTecle [1] para tentar novamente ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cagendamento->salvar, 0);

        switch (cagendamento->salvar[0])
        {
        case '1':
            cancelar_agendamento();
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    while ((strcmp(cagendamento->salvar, "1") != 0 || strcmp(cagendamento->salvar, "2") != 0))
    {
        memset(cagendamento->salvar, 0, sizeof(cagendamento->salvar));

        printf("\n\nTecle [1] para confirmar a EXCLUSAO desse agendamento ou [2] para VOLTAR ao menu anterior: ");
        tratamento_numeroum(cagendamento->salvar, 0);

        if (strcmp(cagendamento->salvar, "2") == 0)
        {
            remove("dados\\temp_agendamento_del.txt");
            break;
        }

        switch (cagendamento->salvar[0])
        {
        case '1':
            break;
        case '2':
            main_delete();
            break;
        default:
            printf("\033[2J\033[1;1H");
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }

        int rem = 0;
        rem = remove("dados\\cad_agendamento.txt");
        if (rem == 0)
        {
            printf("\nO arquivo foi deletado com sucesso!\n");
            rename("dados\\temp_agendamento_del.txt", "dados\\cad_agendamento.txt");
            break;
        }
        else
        {
            remove("dados\\temp_agendamento_del.txt");
            perror("não foi possível deletar o arquivo!");
            break;
        }
    }
    system("pause");
    main_delete();
}
/*FUNÇÕES*/
int verifica_useradm(void)
{
    const char *buscar_adm = "admin";
    char senha_adm[52];
    char repete_senha_adm[52];

    system("mkdir dados");

    user *usuario = calloc(1, sizeof(user) * 1);

    pfuncionario = fopen("dados\\cad_funcionario.txt", "a+");
    if (pfuncionario == NULL)
    {
        fprintf(stderr, "\n\nErro ao excluir arquivo de funcionarios, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    //Comparar strings com strcmp
    while (!feof(pfuncionario) && strcmp(usuario->usuario, buscar_adm) != 0)
    {
        fscanf(pfuncionario, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &usuario->codigo, usuario->nome, usuario->celular, usuario->email, usuario->cpf, usuario->usuario, usuario->senha, usuario->endereco.estado, usuario->endereco.cidade, usuario->endereco.bairro, usuario->endereco.logradouro, usuario->endereco.complemento, usuario->endereco.cep);
    }
    while (strcmp(usuario->usuario, buscar_adm) != 0)
    {
        memset(senha_adm, 0, sizeof(senha_adm));
        memset(repete_senha_adm, 0, sizeof(repete_senha_adm));
        /*Cadastro dos dados*/
        printf("\033[2J\033[1;1H");
        printf("\n============ CADASTRO DO USUARIO ADMINISTRADOR ============\n\n");
        printf("Atencao, para o primeiro acesso, cadastre um usuario adminsitrador para acessar o sistema!\n\n");
        printf("Usuario: admin\n");
        printf("Digite a senha: ");
        criptografa_senha(senha_adm, 50);
        printf("\nConfirme a senha: ");
        criptografa_senha(repete_senha_adm, 50);

        //Comparar strings com strcmp
        if (strcmp(senha_adm, repete_senha_adm) == 0)
        {
            fprintf(pfuncionario, "1\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "admin\n");
            fprintf(pfuncionario, "%s\n", senha_adm);
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fprintf(pfuncionario, "00000000000\n");
            fclose(pfuncionario);

            printf("\n\nUsuario administrador cadastrado com sucesso! Tecle ENTER para ir ao painel de login.");
            getchar();
            break;
        }
        else if (strcmp(senha_adm, repete_senha_adm) != 0)
        {
            memset(senha_adm, 0, sizeof(senha_adm));
            memset(repete_senha_adm, 0, sizeof(repete_senha_adm));
            printf("\n\nAs senhas não conferem, adicione senhas iguais!\n\n");
            printf("\nTecle ENTER para tentar novamente!\n");
            getchar();
        }
    }
    fclose(pfuncionario);
    return 0;
}

int tela_login(void)
{
    int i, tam_msg;
    char scan[52], scan2[52], crip_msg[52];
    memset(scan, 0, sizeof(scan));
    memset(scan2, 0, sizeof(scan2));
    memset(crip_msg, 0, sizeof(crip_msg));
    pfuncionario = fopen("dados\\cad_funcionario.txt", "r");
    if (pfuncionario == NULL)
    {
        fprintf(stderr, "\n\nErro ao excluir arquivo de funcionarios, pode ser permissao?");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    user *usuario = calloc(1, sizeof(user) * 1);

    /*PAINEL DE LOGIN*/
    printf("\033[2J\033[1;1H");
    printf("\n============ PAINEL DE LOGIN ============\n\n");
    printf("\nFavor digitar o seu usuario e senha!\n");
    printf("\nLOGIN: ");
    scanf("%s", scan);
    printf("\nSENHA: ");

    //Adiciona * nos valores digitados na senha.
    tratamento_senha(scan2, 50);

    //Busca o cadastro no arquivo
    while (!feof(pfuncionario))
    {
        fscanf(pfuncionario, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &usuario->codigo, usuario->nome, usuario->celular, usuario->email, usuario->cpf, usuario->usuario, usuario->senha, usuario->endereco.estado, usuario->endereco.cidade, usuario->endereco.bairro, usuario->endereco.logradouro, usuario->endereco.complemento, usuario->endereco.cep);

        if (strcmp(usuario->usuario, scan) == 0)
        {
            break;
        }
    }

    //Criptografa a senha digitada pelo usuário
    tam_msg = strlen(scan2);
    for (i = 0; i < tam_msg; i++)
    {
        crip_msg[i] = scan2[i] + 5;
    }
    crip_msg[tam_msg] = '\0';

    fclose(pfuncionario);

    //Faz a comparação da senha digitada e criptografada do usuário com a que existe no cadastro
    if (strcmp(usuario->usuario, scan) == 0)
    {
        if (strcmp(usuario->senha, crip_msg) == 0)
        {
            printf("\n\nLOGADO");
            main_principal();
        }
        else
        {
            printf("\n\nUsuario ou senha invalido!\n\n");
            system("pause");
            tela_login();
        }
    }
    else if (strcmp(usuario->usuario, scan) != 0)
    {
        printf("\n\nUsuario ou senha invalido!\n\n");
        system("pause");
        tela_login();
    }
    printf("\n\n\n");
    return 0;
}

void mostrarendereco(void)
{
    printf("11.Endereco(Estado)\n12.Endereco(Cidade)\n13.Endereco(Bairro)\n14.Endereco(Logradouro)\n15.Endereco(Complemento)\n16.Endereco(CEP) \n\nEscolha qual informacao voce deseja alterar e tecle ENTER: \n");
}

void tratamento_desc50(char *tdesc50, int tdesc50_size)
{
    /*TRATAMENTO PARA NOME OU DESCRIÇÃO DE 50 CARACTERES*/
    int i;
    char c;

    memset(tdesc50, 0, tdesc50_size);
    i = 0;
    c = '\0';

    do
    {
        c = getch();
        if (isprint(c) != 0)
        {
            if (i < 50)
            {
                tdesc50[i] = c;
                i++;
                printf("%c", c);
            }
        }
        else if (c == 8 && i)
        {
            tdesc50[i] = '\0';
            i--;
            printf("\b \b");
        }
    } while (c != 13 || i == 0);
    tdesc50[i] = '\0';
}

void tratamento_desc1500(char *tdesc1500, int tdesc1500_size)
{
    /*TRATAMENTO PARA NOME OU DESCRIÇÃO DE 1500 CARACTERES*/
    int i;
    char c;

    memset(tdesc1500, 0, tdesc1500_size);
    i = 0;
    c = '\0';

    do
    {
        c = getch();
        if (isprint(c) != 0)
        {
            if (i < 1498)
            {
                tdesc1500[i] = c;
                i++;
                printf("%c", c);
            }
        }
        else if (c == 8 && i)
        {
            tdesc1500[i] = '\0';
            i--;
            printf("\b \b");
        }
    } while (c != 13 || i == 0);
    tdesc1500[i] = '\0';
}

void tratamento_estado(char *testado, int testado_size)
{
    /*TRATAMENTO PARA O ESTADO*/
    int i;
    char c;

    memset(testado, 0, testado_size);
    i = 0;
    c = '\0';

    do
    {
        c = getch();
        if (isprint(c) != 0)
        {
            if (i < 2)
            {
                testado[i] = c;
                i++;
                printf("%c", c);
            }
        }
        else if (c == 8 && i)
        {
            testado[i] = '\0';
            i--;
            printf("\b \b");
        }
    } while (c != 13 || i == 0 || i < 2);
    testado[i] = '\0';
}

void tratamento_cpf(char *tcpf, int tcpf_size)
{
    /*TRATAMENTO PARA O CPF*/

    int i;
    char c;

    memset(tcpf, 0, tcpf_size);
    i = 0;
    c = '\0';
    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i < 11)
            {
                tcpf[i] = c;
                i++;
                printf("%c", c);
                if (i == 3 || i == 6)
                {
                    printf(".");
                }
                else if (i == 9)
                {
                    printf("-");
                }
            }
        }
        else if (c == 8 && i)
        {
            if (i == 3 || i == 6 || i == 9)
            {
                printf("\b \b");
                tcpf[i] = '\0';
                i--;
                printf("\b \b");
            }
            else
            {
                tcpf[i] = '\0';
                i--;
                printf("\b \b");
            }
        }
    } while (c != 13 || i == 0 || i < 11);
    tcpf[i] = '\0';
}

void tratamento_data(char *tdata, int tdata_size)
{
    /*TRATAMENTO PARA A DATA*/

    int i;
    char c;

    memset(tdata, 0, tdata_size);
    i = 0;
    c = '\0';
    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i <
            {
                tdata[i] = c;
                i++;
                printf("%c", c);
                if (i == 2 || i == 4)
                {
                    printf("/");
                }
            }
        }
        else if (c == 8 && i)
        {
            if (i == 2 || i == 4)
            {
                printf("\b \b");
                tdata[i] = '\0';
                i--;
                printf("\b \b");
            }
            else
            {
                tdata[i] = '\0';
                i--;
                printf("\b \b");
            }
        }
    } while (c != 13 || i == 0 || i < 8);
    tdata[i] = '\0';
}

void tratamento_tdta(char *tdta, int tdta_size)
{
    int d, m, a;

    //ponteiro para struct que armazena data e hora
    struct tm *data_hora_atual;

    //variável do tipo time_t para armazenar o tempo em segundos
    time_t segundos;

    //obtendo o tempo em segundos
    time(&segundos);

    //para converter de segundos para o tempo local
    //utilizamos a função localtime
    data_hora_atual = localtime(&segundos);

    do
    {
        d = 0, m = 0, a = 0;

        memset(tdta, 0, tdta_size);

        tratamento_data(tdta, 8);

        sscanf(tdta, "\n%2d %2d %4d", &d, &m, &a);

        if (((d < data_hora_atual->tm_mday || d > 31) && (m < data_hora_atual->tm_mon + 1 || m == data_hora_atual->tm_mon + 1 || m > 12) && (a <= data_hora_atual->tm_year + 1900)) || (a < data_hora_atual->tm_year + 1900) || (d > data_hora_atual->tm_mday && m > 12))
        {
            printf("\n\nData invalida, tente outra!\n");
            printf("\nData do agendamento: \n");
        }

    } while (((d < data_hora_atual->tm_mday || d > 31) && (m < data_hora_atual->tm_mon + 1 || m == data_hora_atual->tm_mon + 1 || m > 12) && (a <= data_hora_atual->tm_year + 1900)) || (a < data_hora_atual->tm_year + 1900) || (d > data_hora_atual->tm_mday && m > 12));
}

void tratamento_dataqq(char *tdataqq, int tdataqq_size)
{
    /*TRATAMENTO PARA A DATA*/

    int i;
    char c;

    memset(tdataqq, 0, tdataqq_size);
    i = 0;
    c = '\0';
    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i <
            {
                tdataqq[i] = c;
                i++;
                printf("%c", c);
                if (i == 2 || i == 4)
                {
                    printf("/");
                }
            }
        }
        else if (c == 8 && i)
        {
            if (i == 2 || i == 4)
            {
                printf("\b \b");
                tdataqq[i] = '\0';
                i--;
                printf("\b \b");
            }
            else
            {
                tdataqq[i] = '\0';
                i--;
                printf("\b \b");
            }
        }
    } while (c != 13 || i == 0 || i < 8);
    tdataqq[i] = '\0';
}

void tratamento_tdtaqq(char *tdtaqq, int tdtaqq_size)
{
    int d, m, a;

    do
    {
        d = 0, m = 0, a = 0;

        memset(tdtaqq, 0, tdtaqq_size);

        tratamento_data(tdtaqq, 8);

        sscanf(tdtaqq, "\n%2d %2d %4d", &d, &m, &a);

        if ((d > 31) || ( m > 12) || (a < 2000))
        {
            printf("\n\nData invalida, tente outra!\n");
            printf("\nData do agendamento: \n");
        }

    } while ((d > 31) || ( m > 12) || (a < 2020));
}

void tratamento_hora(char *thora, int thora_size)
{
    /*TRATAMENTO PARA A HORA*/

    int i;
    char c;

    memset(thora, 0, thora_size);
    i = 0;
    c = '\0';
    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i < 4)
            {
                thora[i] = c;
                i++;
                printf("%c", c);
                if (i == 2)
                {
                    printf(":");
                }
            }
        }
        else if (c == 8 && i)
        {
            if (i == 2)
            {
                printf("\b \b");
                thora[i] = '\0';
                i--;
                printf("\b \b");
            }
            else
            {
                thora[i] = '\0';
                i--;
                printf("\b \b");
            }
        }
    } while (c != 13 || i == 0 || i < 4);
    thora[i] = '\0';
}

void tratamento_numero(char *tnum, int tnum_size)
{
    /*TRATAMENTO PARA NUMERO*/

    int i;
    char c;

    memset(tnum, 0, tnum_size);
    i = 0;
    c = '\0';
    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i < 2)
            {
                tnum[i] = c;
                i++;
                printf("%c", c);
            }
        }
        else if (c == 8 && i)
        {
            tnum[i] = '\0';
            i--;
            printf("\b \b");
        }
    } while (c != 13 || i == 0);
    tnum[i] = '\0';
}

void tratamento_numeroum(char *tnumum, int tnumum_size)
{
    /*TRATAMENTO PARA NUMERO*/

    int i;
    char c;

    memset(tnumum, 0, tnumum_size);
    i = 0;
    c = '\0';
    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i < 1)
            {
                tnumum[i] = c;
                i++;
                printf("%c", c);
            }
        }
        else if (c == 8 && i)
        {
            tnumum[i] = '\0';
            i--;
            printf("\b \b");
        }
    } while (c != 13 || i == 0);
    tnumum[i] = '\0';
}

void tratamento_hm(char *thm, int thm_size)
{
    int h, m;

    do
    {
        h = 0, m = 0;
        memset(thm, 0, thm_size);

        tratamento_hora(thm, 4);

        sscanf(thm, "\n%2d %2d", &h, &m);

        if (h > 23 || m > 59)
        {
            printf("\n\nFavor digite a hora entre 00 e 23 e os minutos entre 00 e 59!\n");
            printf("\nHora do agendamento: \n");
        }

    } while (h > 23 || m > 59);
}

void tratamento_cnpj(char *tcnpj, int tcnpj_size)
{
    int i;
    char c;

    memset(tcnpj, 0, tcnpj_size);
    i = 0;
    c = '\0';
    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i < 14)
            {
                tcnpj[i] = c;
                i++;
                printf("%c", c);
                if (i == 2 || i == 5)
                {
                    printf(".");
                }
                else if (i ==
                {
                    printf("/");
                }
                else if (i == 12)
                {
                    printf("-");
                }
            }
        }
        else if (c == 8 && i)
        {
            if (i == 2 || i == 5 || i == 8 || i == 12)
            {
                printf("\b \b");
                tcnpj[i] = '\0';
                i--;
                printf("\b \b");
            }
            else
            {
                tcnpj[i] = '\0';
                i--;
                printf("\b \b");
            }
        }
    } while (c != 13 || i == 0 || i < 14);
}

void tratamento_senha(char *tsenha, int tsenha_size)
{
    /*TRATAMENTO PARA A SENHA*/
    int i;
    char c;

    memset(tsenha, 0, tsenha_size);
    c = '\n';
    i = 0;
    //Adiciona * nos valores digitados na senha.
    do
    {
        c = _getch();

        if (isprint(c))
        {
            if (i < 48)
            {
                tsenha[i++] = c;
                printf("%c", '*');
            }
        }
        else if (c == 8 && i)
        {
            tsenha[i--] = '\0';
            printf("%s", "\b \b");
        }

    } while (c != 13 || i == 0);
}

void tratamento_celular(char *tcelular, int tcelular_size)
{
    /*TRATAMENTO PARA O CELULAR*/
    int i;
    char c;

    memset(tcelular, 0, tcelular_size);
    i = 0;
    c = '\0';

    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i < 11)
            {
                tcelular[i] = c;
                i++;
                printf("%c", c);
                if (i == 2)
                {
                    printf("-");
                }
                else if (i == 7)
                {
                    printf("-");
                }
            }
        }
        else if (c == 8 && i)
        {
            if (i == 2 || i == 7)
            {
                printf("\b \b");
                tcelular[i] = '\0';
                i--;
                printf("\b \b");
            }
            else
            {
                tcelular[i] = '\0';
                i--;
                printf("\b \b");
            }
        }
    } while (c != 13 || i == 0 || i < 11);
}

void tratamento_cep(char *tcep, int tcep_size)
{
    /*TRATAMENTO PARA O CEP*/
    int i;
    char c;

    memset(tcep, 0, tcep_size);
    i = 0;
    c = '\0';

    do
    {
        c = getch();
        if (isdigit(c) != 0)
        {
            if (i <
            {
                tcep[i] = c;
                i++;
                printf("%c", c);
                if (i == 5)
                {
                    printf("-");
                }
            }
        }
        else if (c == 8 && i)
        {
            if (i == 5)
            {
                printf("\b \b");
                tcep[i] = '\0';
                i--;
                printf("\b \b");
            }
            else
            {
                tcep[i] = '\0';
                i--;
                printf("\b \b");
            }
        }
    } while (c != 13 || i == 0 || i < 8);
}

void incrementa_id_func(int *IDinc_func)
{
    pfuncionario = fopen("dados\\cad_funcionario.txt", "r");
    if (pfuncionario == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de funcionarios ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    user *usuarioi = calloc(1, sizeof(user) * 1);

    while (!feof(pfuncionario))
    {
        fscanf(pfuncionario, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &usuarioi->codigo, usuarioi->nome, usuarioi->celular, usuarioi->email, usuarioi->cpf, usuarioi->usuario, usuarioi->senha, usuarioi->endereco.estado, usuarioi->endereco.cidade, usuarioi->endereco.bairro, usuarioi->endereco.logradouro, usuarioi->endereco.complemento, usuarioi->endereco.cep);
    }
    fclose(pfuncionario);
    *IDinc_func = usuarioi->codigo;
}

void incrementa_id_paci(int *IDinc_paci)
{
    patleta = fopen("dados\\cad_atleta.txt", "r");
    if (patleta == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de pacientes ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    athlete *atletai = calloc(1, sizeof(athlete) * 1);

    while (!feof(patleta))
    {
        fscanf(patleta, "%d\n %[^\n] %[^\n]s", &atletai->codigo, atletai->nome, atletai->pais);
    }
    fclose(patleta);
    *IDinc_paci = atletai->codigo;
}

void incrementa_id_medi(int *IDinc_medi)
{
    pdoctor = fopen("dados\\cad_medico.txt", "r");
    if (pdoctor == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de medicos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    doctor *medicoi = calloc(1, sizeof(doctor) * 1);

    while (!feof(pdoctor))
    {
        fscanf(pdoctor, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", &medicoi->codigo, medicoi->nome, medicoi->celular, medicoi->email, medicoi->cpf, medicoi->especialidade);
    }
    fclose(pdoctor);
    *IDinc_medi = medicoi->codigo;
}

void incrementa_id_fili(int *IDinc_fili)
{
    ptreint = fopen("dados\\cad_trint.txt", "r");
    if (ptreint == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de Local de treinamento ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    localtrein *localtreini = calloc(1, sizeof(localtrein) * 1);

    while (!feof(ptreint))
    {
        fscanf(ptreint, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n]s", localtreini->logradouro, localtreini->complemento, localtreini->bairro, localtreini->cidade, localtreini->estado, localtreini->cp);
    }
    fclose(ptreint);

}

void incrementa_id_agen(int *IDinc_agen)
{
    pagendamento = fopen("dados\\cad_agendamento.txt", "r");
    if (pagendamento == NULL)
    {
        fprintf(stderr, "\n\nErro ao abrir arquivo de agendamentos ou ainda não foi realizado nenhum cadastro!");

        char verificaarq[2];
        memset(verificaarq, 0, sizeof(verificaarq));

        printf("\n\nTecle [1] para voltar ao menu principal ou [2] para sair do programa: ");
        tratamento_numeroum(verificaarq, 0);

        switch (verificaarq[0])
        {
        case '1':
            main_principal();
            break;
        case '2':
            exit(0);
        default:
            printf("\nMenu inexistente, tente novamente [1] ou [2].");
            system("pause");
        }
    }

    scheduling *agendamentoi = calloc(1, sizeof(scheduling) * 1);

    while (!feof(pagendamento))
    {
        fscanf(pagendamento, "%d\n %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %[^\n] %f\n %[^\n]s", &agendamentoi->codigo, agendamentoi->atleta.codigo, agendamentoi->atleta.nome, agendamentoi->medico.cpf, agendamentoi->medico.nome, agendamentoi->data, agendamentoi->hora, agendamentoi->descricao);
    }
    fclose(pagendamento);
    *IDinc_agen = agendamentoi->codigo;
}
void criptografa_senha(char *crip_msg, int senha_encript_size)
{
    int i, tam_msg = 0;
    char senha_cript[52], c;

    memset(senha_cript, 0, sizeof(senha_cript));
    memset(crip_msg, 0, senha_encript_size);
    c = '\n';
    i = 0;
    tam_msg = 0;
    //Adiciona * nos valores digitados na senha.
    do
    {
        c = _getch();

        if (isprint(c))
        {
            if (i < 50)
            {
                senha_cript[i++] = c;
                printf("%c", '*');
            }
        }
        else if (c == 8 && i)
        {
            senha_cript[i--] = '\0';
            printf("%s", "\b \b");
        }

    } while (c != 13 || i == 0);

    /*GRAVAR OS DADOS NO ARQUIVO DE TEXTO*/
    tam_msg = strlen(senha_cript);
    for (i = 0; i < tam_msg; i++)
    {
        crip_msg[i] = senha_cript[i] + 5;
    }
    crip_msg[tam_msg] = '\0';
}
 

[devair1010]

@Lucas Staffa qual erro que se apresenta   ?

[Lucas Staffa]

Na ultima chave, aparece erro de declaração de input 

[devair1010]

@Lucas Staffa    tem muitos outros erros  ,  esse código está muito extenso ,  seria melhor ir testando cada função e trecho do código até que esteja funcionando bem , para depois passar para outras partes ,  e seria melhor você postar o enunciado ,