Incremento com exceção de ponto flutuante

[arcsaraiva]

Prezados,

estou tentando fazer com que uma função que incremente duas variáveis (w e offset) que inicia no 0 e é populada de acordo com um array pré-existente. Funciona bem em quanto o array existe, porém em um dos loops, estoura o tamanho do array. Por exemplo, no código abaixo meu array possui apenas 6 elementos e seus valores são 0, 1, 3, 7, 10 e 15 nas posições de 0 a 5, porém na execução em dado momento o w e o offset recebe o valor 6 e retorna exceção de ponto flutuante. Troquei o incremento de posição varias vezes sem exito. 

t_pp_bd * genPP(t_bd * pattern, t_bd * pattern2, int mmc) {

	t_pp_bd * pp;
	int i, j, z, k, a, b, c, index, offset;

	/*
	 * Allocate structures.
	 */

	pp = (t_pp_bd *) malloc(sizeof(t_pp_bd));
	pp->offsetZero.coincidences = (int *) malloc(pattern->k * sizeof(int));
	pp->offsetZero.index = (int *) malloc(pattern->v * sizeof(int));
	pp->others.coincidences = (int *) malloc(sizeof(int));
	pp->others.index = (int *) malloc(pattern->v * sizeof(int));
	pp->v = pattern->v;
	pp->k = pattern->k;
	pp->v = pattern2->v;
	pp->k = pattern2->k;



	/*
	 * Creation of the MMC index for offset 0
	 */
	
	// First pattern -> aqui é geradoum padrão do tipo 110110110110110...
		
		z = 0;
		j = 0;
		int menor[mmc];
		memset(menor, 0, mmc*sizeof(int));
		while (z < mmc/pattern->v) {
			for (i=0; i <= pattern->k; i++){
				menor[(pattern->onSlots[i] + z*pattern->v) % mmc] = 1;
				//printf("menor %d-> %d\n",j, menor[j]);
				j++;
				};
			z++;
		}

	// Second pattern -> aqui é gerado um padrão 110100011010001101000...
	
		a = 0;
		b = 0;
		int maior[mmc];
		memset(maior, 0, mmc*sizeof(int));
		while (a < mmc/pattern->v) {
			for (c=0; c < pattern2->k; c++){
				maior[((pattern2->onSlots[c] + a*pattern2->v) % mmc)] = 1;				
				//printf("maior %d-> %d\n",b, maior[b]);
				b++;
				}
			a++;
		}
				

	// Comparation of pattern of offset 0 -> nessa função verifica as posições onde os 1´s coincidem até 21 (0,1,3,7,10 e 15)
		int w=0;
		for (k=0; k < mmc; k++){
			printf("W= %d\n",w);
			printf("offsetZero = %d\n",pp->offsetZero.k);
			printf("-------------------");
			if ((menor[k] == 1) && (maior[k]==1)){			//a ideia é fazer qie offsetZero.coicidences[w] armazene na posição 0 o valor 0, na posição 1 o valor 1, na posição 2 o valor 3, na posição 4 o valor 7, na posição 5 o valor 10...
				printf("ACHOU em %d, menor %d, maior %d\n",k, menor[k], maior[k]);
				pp->offsetZero.coincidences[w] = k;
				printf("W= %d\n",w);
				printf("offsetZero = %d\n",pp->offsetZero.k);
				pp->offsetZero.k++;
				w++;
				printf("-------------------");
				printf("W= %d\n",w);
				printf("offsetZero = %d\n",pp->offsetZero.k);
				j = 0;		
				for (i = 0; i < pp->offsetZero.k; i++) {

					while(j <= pp->offsetZero.coincidences[i]) {

						pp->offsetZero.index[j++] = i;
					}
				}

				while(j < pp->v) {

					pp->offsetZero.index[j++] = 0;
				}
			}
		}


	return(pp);
} 

O problema é que durante a execução, o k e o offset recebem o valor 6  (que deveria ir até o 5) e acontece a exceção. Alguém poderia me ajudar?