for (i0 = 0; i0 < inputStrs->m_str[0].m_length - motifLen; i0++)
{
        totNumDNeighs = 0;
        HashStrV2_Reset(&hashStr);
        strsTemp[0] = (unsigned char *)(inputStrs->m_str[0].m_data + i0);
        for (group = 0; group <= maxGroup; group++) {

            numHits = 0;
            maxNumDNeighs = 0;
            tot_grps = 1;

            strIndex1 = 2 * group + 1;
            strIndex2 = 2 * group + 2;
            subT1 = time(NULL);
                    gettimeofday(&v1, 0); //start timer
            for (i1 = 0; i1 < inputStrs->m_str[strIndex1].m_length - motifLen; i1++) {
                strsTemp[1] = (unsigned char *)(inputStrs->m_str[strIndex1].m_data + i1);
                a01 = hdmat[strIndex1][i0][i1];
                if ( a01 > 2 * hammingDist ) {
                    continue;
                }
                for (i2 = 0; i2 < inputStrs->m_str[strIndex2].m_length - motifLen; i2++) {
                    strsTemp[2] = (unsigned char *)(inputStrs->m_str[strIndex2].m_data + i2);
                    a02 = hdmat[strIndex2][i0][i2];
                    if ( a02 > 2 * hammingDist ) {
                        continue;
                    }
                    a12 = HammingDistStrStr(strsTemp[1], strsTemp[2], motifLen);
                    if ( a12 > 2 * hammingDist ) {
                        continue;
                    }
                    tot_strs++;

                    int outIndex1, outIndex2, outIndex3, outStr1, outStr2, outStr3;

                    ChooseRootStr3Strs_group(a01, a02, a12, 0, strIndex1, strIndex2,
                                        i0, i1, i2, &outStr1, &outStr2, &outStr3,
                                        &outIndex1, &outIndex2, &outIndex3);
                    find_triplet_group(inputStrs, outStr1, outIndex1, outStr2, outIndex2, outStr3, outIndex3, motifLen);
                } //end i1
            } //end i2

            // Now find the d-neighborhood of all the groups
            for(i = 1; i < tot_grps; i++)
            {
                if (group == 0)
                {
                    numDNeighs = GenDNeigh3Strs_new_group(inputStrs, i, i0, strIndex1, strIndex2, hashStr.m_lastStr, hammingDist,
                                                          motifLen, comMotifLen, 1,
                                                          maxDNeighsAllowed > (hashStr.m_bucketBufMaxSize - hashStr.m_bucketTotalSize)?
                                                          (hashStr.m_bucketBufMaxSize - hashStr.m_bucketTotalSize): maxDNeighsAllowed);
                    if(numDNeighs <= 0)
                        continue;
                    if (hashStr.m_bucketTotalSize + numDNeighs < hashStr.m_bucketBufMaxSize) {
                        hashStr.m_bucketTotalSize += numDNeighs;
                        hashStr.m_lastStr += comMotifLen * numDNeighs;
                    }
                }
                else
                {
                    numDNeighs = GenDNeigh3Strs_new_group(inputStrs, i, i0, strIndex1, strIndex2, dNeighsBuf, hammingDist,
                                                          motifLen, comMotifLen, 0, maxDNeighsAllowed);
                    if(numDNeighs <= 0) continue;
                    EncodeManyDNAStrings(dNeighsBuf, numDNeighs, motifLen, dNeighsBuf);

                    gettimeofday(&v3, 0); //start timer for intersection time
                    if (isWithHash[0] == 'y' || isWithHash[0] == 'Y') {
                        dNeighsEnd = dNeighsBuf + comMotifLen * numDNeighs;
                        for (dNeighsRun = dNeighsBuf; dNeighsRun < dNeighsEnd; dNeighsRun += comMotifLen) {
                            HashStrV2_FindAndMarkString(&hashStr, dNeighsRun);
                        }
                    }
                    gettimeofday(&v4, 0); //end timer for intersection time
                    interTime += (v4.tv_sec - v3.tv_sec) * 1000000 + (v4.tv_usec - v3.tv_usec);
                }
                numHits += numDNeighs;
                totNumDNeighs += numDNeighs;
                if (maxNumDNeighs < numDNeighs) {
                    maxNumDNeighs = numDNeighs;
                }
                // Reset this group
                grp_index[grp_desc[i][0]][grp_desc[i][1]][grp_desc[i][2]][grp_desc[i][3]] = 0;
            }
            gettimeofday(&v2, 0);
            genTime += (v2.tv_sec - v1.tv_sec) * 1000000 + (v2.tv_usec - v1.tv_usec);

            if ( group == 0) {
                  HashStrV2_SortStrings(&hashStr);
                  HashStrV2_RemoveDuplicateStrings(&hashStr);
                  HashStrV2_UpdateBucketPointers(&hashStr);
            } else {
                  HashStrV2_RmvUmrkdStrAndUpdtBcktPtr(&hashStr);
            }
            HashStrV2_ResetMarkBucket(&hashStr, 0);
            if (hashStr.m_bucketTotalSize < 500) {
                break;
            }

        }//end group


        if (totCanMotifs + hashStr.m_bucketTotalSize < maxCanMotifsAllowed) {
            memcpy( canMotifsBuf + totCanMotifs * hashStr.m_strLen,
                    hashStr.m_bucketBuf, hashStr.m_bucketTotalSize * hashStr.m_strLen);
            totCanMotifs += hashStr.m_bucketTotalSize;
        }


        t2 = time(NULL);
            total_genTime += (genTime - interTime);

        if ( (i0 % 20) == 0) {
            fprintf(stderr, "\ni0=%d nNodes=%d totNNeis=%d T=%d(s) generation=%lld(us), intersection=%lld(us)\n",
                            i0, numExploredNodes, totNumDNeighs, (t2 - t1), genTime - interTime, interTime/*t2 - t1*/);
        }

        genTime = interTime = 0;
    }//end i0

    fprintf(stderr, "\n Total generation time = %lld(s)\n", total_genTime);