When entering values that give the same key, program the run-time error. Linked list problem

Runtime Error

When you enter the enrollment values into which they are converted into keys for a hash-table . The values that conflict and fall into the same key. They are rescued in nodes for a Chained List . Repeated enrollment is not accepted. The problem is that when entering the values: 201721344, 201821344, 201921344 (...), they conflict because they fall into the same key (44). When inserted in the linked list. There is a run-time error ;

Here are the codes, divided into two files

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#define TAM 50
#define CALCULO_HASH(valor) valor % TAM
#include "alunos.h"


int main(int argc, char *argv[]) {

  setlocale(LC_ALL,"");

    struct aluno alunos[TAM], *ponteiro;
    ponteiro = alunos;

  for (int i = 0; i < TAM; i++) {
    (ponteiro+i)->prox = NULL;
    (ponteiro+i)->matricula = 0;
  }

    unsigned short int opcao;
  while (1) {
    opcao = 0;
    printf("===========  MENU  ===========\n");

    printf("1.Inserir \n");
    printf("2.Remover \n");
    printf("3.Visualizar \n");
    printf("4.Sair...");
    printf("OPÇÃO: ");
    scanf("%hu", &opcao);

    switch (opcao) {
      case 1: {
        insert(ponteiro);
        break;
      }
      case 2: {
        printf("\nRemovendooooo..\n");
        break;
      }
      case 3: {
        printf("\nvisualizando...\n");
        break;
      }
      case 4: {
        printf("Saindo...!\n");
        return 0;
      }
    }
  }
}

Second File

struct aluno {
    unsigned int matricula;
    char nome[50];
    char uNome[50];
    char email[100];
    struct aluno *prox;
};


// PROTÓTIPOS {

int insert (struct aluno *ponteiro);
short int verificaCadastro (const unsigned int matricula, const unsigned int original);
struct aluno *insereLista (struct aluno *n, char nome[], char unome[], unsigned int *matricula, char email[]);
void clsBuffer(void);

// }

void clsBuffer (void) {
  while (getchar() != '\n');
}



short int verificaCadastro (const unsigned int matricula, const unsigned int original) {

  /*
  ========================== SOBRE RETORNOS DA FUNÇÃO ==========================

  =========================== CASO A FUNÇÃO RETORNE: ===========================
    ?
    ?  -1: As matrículas não são iguais;
    ?   1: As matrículas são iguais e deseja-se recadastrar a existente;
    ?   0: As matrículas são iguais mas, deseja-se manter como está.
     ===========================================================================
  */

  if (original == matricula) {

    char aux = 0;
    printf("Matricula já está cadastrada. Deseja recadastrar? (s/n): ");

    while (1) {
      scanf("%c", &aux);
      while (getchar() != '\n');
      switch (aux) {
        case 'S': {
          return 1;
          break;
        }
        case 's': {
          return 1;
          break;
        }
        case 'N': {
          return 0;
          break;
        }
        case 'n': {
          return 0;
          break;
        }
        default: {
          printf("Seleção inválida.. :(\nOpção (s/n): ");
          break;
        }
      }
    }
  }
  return -1;
}

struct aluno *insereLista (struct aluno *n, char nome[], char unome[], unsigned int *matricula, char email[]) {

  if (!n) {

    /*
        Se a lista estiver vázia, será inserido o elemento em primeiro lugar e
        retornado o valor que foi recebido, que no caso é NULL (Vázio). 
        O elemento NULL delimita o fim da lista Encadeada;
    */

    struct aluno *novo = (struct aluno *)malloc (sizeof(struct aluno));
    novo->prox = n;

    novo->matricula = *matricula;

    strcpy(novo->email, email);
    strcpy(novo->nome, nome);
    strcpy(novo->uNome, unome);

    return novo;
  } else {

    /*
      O programa entra nessa condição caso a lista já esteja com dois ou mais
      elementos inseridos. Os nós serão verificados, e caso não tenha nenhuma
      matricula repetida, será encadeado a o final da lista e o final (que é NULL)
      será mantido em último lugar.
    */

    struct aluno *ant, *p;
    p = n;
    ant = NULL;
    while (p != NULL && p->matricula != *matricula) {
      ant = p;
      p = p->prox;
    }

    int aux = verificaCadastro(p->matricula, *matricula);
    if (aux == -1) {
      struct aluno *novo = (struct aluno *)malloc (sizeof(struct aluno));

      novo->matricula = *matricula;

      strcpy(novo->email, email);
      strcpy(novo->nome, nome);
      strcpy(novo->uNome, unome);


      novo->prox = p;
      ant->prox = novo;
    } else if (aux) {
      p->matricula = *matricula;

      strcpy(p->email, email);
      strcpy(p->nome, nome);
      strcpy(p->uNome, unome);
    }
    return n;
  }
}



int insert (struct aluno *ponteiro) {

  printf("=========== INSERÇÃO ==========\n");


  char pNome[50];
  char uNome[50];
  char email[100];
  unsigned int matricula;

  printf("Matricula: ");
  scanf("%u", &matricula);
  clsBuffer();

  printf("Primeiro nome: ");
  fgets(pNome, 50, stdin);

  printf("Ultimo nome: ");
  fgets(uNome, 50, stdin);

  printf("Email: ");
  fgets(email, 100, stdin);

  unsigned short int chave = CALCULO_HASH(matricula);

  printf("chave: %hu", chave);

  if ((ponteiro+chave)->matricula) {

    short int aux = verificaCadastro(matricula, (ponteiro+chave)->matricula);
    if (aux == -1) {
      (ponteiro+chave)->prox = insereLista((ponteiro+chave)->prox, pNome, uNome, &matricula, email);
      return 1;
    } else if (!aux) {
      return 0;
    }
  }

  (ponteiro+chave)->matricula = matricula;
  strcpy((ponteiro+chave)->nome, pNome);
  strcpy((ponteiro+chave)->uNome, uNome);
  strcpy((ponteiro+chave)->email, email);

  return 1;
}