sim-operations.c

Go to the documentation of this file.

#ifndef SIM_OPERATIONS
#define SIM_OPERATIONS
#include "sim-operations.h"
/* genomicSimulationC v0.3 - last edit 23 July 2025 */
 
const gsc_GenOptions GSC_BASIC_OPT = {
    .will_name_offspring = GSC_FALSE,
    .offspring_name_prefix = NULL,
    .family_size = 1,
    .will_track_pedigree = GSC_FALSE,
    .will_allocate_ids = GSC_TRUE,
    .filename_prefix = NULL,
    .will_save_pedigree_to_file = GSC_FALSE,
    .will_save_bvs_to_file = GSC_NO_EFFECTSET,
    .will_save_alleles_to_file = GSC_FALSE,
    //.will_save_recombinations_to_file = GSC_FALSE,
    .will_save_to_simdata = GSC_TRUE
};
 
static void* gsc_malloc_wrap(const size_t size, char exitonfail) {
    if (size == 0) {
        fprintf(stderr, "0 memory allocation requested.\n");
        return NULL;
    }
    void* v = GSC_MALLOC(size);
    if (v == NULL) {
        if (exitonfail) {
            fprintf(stderr, "Memory allocation failed. Exiting.\n"); exit(2);
        } else {
            fprintf(stderr, "Memory allocation failed.\n");
        }
    }
    return v;
}
 
gsc_AlleleMatrix* gsc_create_empty_allelematrix(const GSC_GENOLEN_T n_markers, 
                                                const GSC_ID_T n_labels, 
                                                const int* labelDefaults, 
                                                const GSC_LOCALX_T n_genotypes) {
    gsc_AlleleMatrix* m = gsc_malloc_wrap(sizeof(gsc_AlleleMatrix),GSC_TRUE);
 
    m->n_genotypes = n_genotypes;
    m->n_markers = n_markers;
    m->n_labels = n_labels;
    //m->alleles = gsc_malloc_wrap(sizeof(char*) * CONTIG_WIDTH);
    for (GSC_LOCALX_T i = 0; i < n_genotypes; ++i) {
        m->alleles[i] = gsc_malloc_wrap(sizeof(char) * (n_markers<<1),GSC_TRUE);
        memset(m->alleles[i], 0, sizeof(char) * (n_markers<<1));
        //m->ids[i] = 0;
    }
    memset(m->alleles + n_genotypes, 0, sizeof(char*) * (CONTIG_WIDTH - n_genotypes)); // setting the pointers to NULL
 
    if (n_labels > 0) {
        m->labels = gsc_malloc_wrap(sizeof(int*) * n_labels,GSC_TRUE);
        for (GSC_ID_T i = 0; i < n_labels; ++i) {
            m->labels[i] = gsc_malloc_wrap(sizeof(int) * CONTIG_WIDTH,GSC_TRUE);
            for (GSC_LOCALX_T j = 0; j < CONTIG_WIDTH; ++j) {
                m->labels[i][j] = labelDefaults[i];
            }
        }
    } else if (n_labels == 0) {
        m->labels = NULL;
    } else {
        fprintf(stderr, "Invalid negative number of labels provided to gsc_create_empty_allelematrix");
        m->labels = NULL;
    }
 
    memset(m->ids, 0, sizeof(gsc_PedigreeID) * CONTIG_WIDTH);
    memset(m->pedigrees[0], 0, sizeof(gsc_PedigreeID) * CONTIG_WIDTH);
    memset(m->pedigrees[1], 0, sizeof(gsc_PedigreeID) * CONTIG_WIDTH);
    memset(m->groups, 0, sizeof(gsc_GroupNum) * CONTIG_WIDTH);
    memset(m->names, 0, sizeof(char*) * CONTIG_WIDTH); // setting the pointers to NULL
 
    m->next = NULL;
 
    return m;
}
 
gsc_SimData* gsc_create_empty_simdata(RND_U32 RNGseed) {
    gsc_SimData* d = gsc_malloc_wrap(sizeof(gsc_SimData),GSC_TRUE);
    d->n_labels = 0;
    d->label_ids = NULL;
    d->label_defaults = NULL;
    d->genome.n_markers = 0;
    d->genome.marker_names = NULL;
    d->genome.names_alphabetical = NULL;
    d->genome.n_maps = 0;
    d->genome.map_ids = NULL;
    d->genome.maps = NULL;
    d->m = NULL;
    d->n_eff_sets = 0;
    d->e = NULL;
    rnd_pcg_seed( &d->rng, RNGseed );
    d->current_id = GSC_NO_PEDIGREE;
    d->n_groups = 0;
    return d;
}
 
void gsc_clear_simdata(gsc_SimData* d) {
    if (d == NULL) return;
    // Free label defaults
    if (d->n_labels > 0) {
        if (d->label_ids != NULL) {
            GSC_FREE(d->label_ids);
        }
        if (d->label_defaults != NULL) {
            GSC_FREE(d->label_defaults);
        }
    }
 
    // Free other details
    gsc_delete_genome(&(d->genome));
    for (GSC_ID_T i = 0; i < d->n_eff_sets; ++i) {
        gsc_delete_effects_table(&(d->e[i]));
    }
    if (d->n_eff_sets > 0) {
        GSC_FREE(d->eff_set_ids);
        for (GSC_ID_T i = 0; i < d->n_eff_sets; ++i) {
            gsc_delete_effects_table(&(d->e[i]));
        }
        GSC_FREE(d->e);
    }
    gsc_delete_allele_matrix(d->m);
 
    // Clear all values but the RNG
    d->n_labels = 0;
    d->label_ids = NULL;
    d->label_defaults = NULL;
    d->genome.n_markers = 0;
    d->genome.marker_names = NULL;
    d->genome.n_maps = 0;
    d->genome.map_ids = NULL;
    d->genome.maps = NULL;
    d->m = NULL;
    d->n_eff_sets = 0;
    d->eff_set_ids = NULL;
    d->e = NULL;
    // d->rng
    d->current_id = GSC_NO_PEDIGREE;
    d->n_groups = 0;
}
 
/*-------------------------Random generators---------------------------------*/
 
/* https://www.everything2.com/title/Generating+random+numbers+with+a+Poisson+distribution
https://en.wikipedia.org/wiki/Poisson_distribution#Generating_Poisson-distributed_random_variables
*/
int gsc_randpoi(rnd_pcg_t* rng, double lambda) {
    if (lambda <= 0) { // invalid parameter.
        //In this case we use the function to generate number of crossovers
        // so if parameter/length passed in is invalid, we just want no crossovers
        return 0;
    }
 
    int k = 0;
    double target = exp(-lambda);
    double p = rnd_pcg_nextf(rng);
    while (p > target) {
        k += 1;
        p *= rnd_pcg_nextf(rng);
    }
    return k;
}
 
/*end random generators*/
 
/*------------------------Supporter Functions--------------------------------*/
 
struct gsc_TableSize gsc_get_file_dimensions(const char* filename, const char sep) {
    struct gsc_TableSize details;
    details.num_columns = 0;
    details.num_rows = 0;
 
    FILE* fp;
    int c; // this is used to store the output of fgetc i.e. the next character in the file
    if ((fp = fopen(filename, "r")) == NULL) {
        fprintf(stderr, "Failed to open file %s.\n", filename); exit(1);
    }
    c = fgetc(fp);
 
    while (c != EOF && c != '\n') {
        //RPACKINSERT R_CheckUserInterrupt();
        if (c == sep) {
            details.num_columns += 1; // add count for columns of form [colname]sep
        }
        c = fgetc(fp);
    }
 
    details.num_columns += 1; // add another column that was bounded by sep[colname][EOF or \n]
    details.num_rows = 1; // we successfully got the first row
 
    // now get all the rows. What we care about in the rows is the number of them
    c = fgetc(fp);
    int sep_count = 0; // for each row, count the columns to make sure they match and the file is valid
    int has_length = GSC_FALSE;
    while (c != EOF) {
        //RPACKINSERT R_CheckUserInterrupt();
        if (c == '\n') {
            details.num_rows += 1; // add count for columns of form [colname]sep
 
            // check we have right number of columns and reset counter
            if (has_length && sep_count != details.num_columns-1) {
                // we have a bad number of columns
                details.num_columns = 0;
                fclose(fp);
                fprintf(stderr, "Bad columns on row %d\n", details.num_rows + 1); exit(1);
            }
            sep_count = 0;
            has_length = GSC_FALSE;
 
        } else if (c == sep) {
            sep_count += 1;
        } else if (has_length == GSC_FALSE) {
            has_length = GSC_TRUE;
        }
        c = fgetc(fp);
    }
    if (has_length) {
        details.num_rows += 1; // for the last row before EOF
    }
 
    fclose(fp);
    return details;
}
 
/*int gsc_get_from_ordered_uint_list(const unsigned int target, 
                                   const unsigned int listLen, 
                                   const unsigned int* list) {
    unsigned int first = 0, last = listLen - 1;
    int index = (first + last) / 2;
    while (list[index] != target && first <= last) {
        if (list[index] == 0) {
            int lookahead = 1;
            while(1) {
                if (index+lookahead <= last && list[index+lookahead] != 0) {
                    if (list[index+lookahead] == target) {
                        return index+lookahead;
                    } else if (list[index+lookahead] < target) {
                        first = index+lookahead + 1;
                        break;
                    } else {
                        last = index - 1;
                        break;
                    }
                } else if (index-lookahead <= last && list[index-lookahead] != 0) {
                    if (list[index-lookahead] == target) {
                        return index-lookahead;
                    } else if (list[index-lookahead] < target) {
                        first = index + 1;
                        break;
                    } else {
                        last = index-lookahead - 1;
                        break;
                    }
                }
                ++lookahead;
                if (index+lookahead <= last || index-lookahead >= first) {
                    // failed to find any nonzeros between first and last
                    return -1;
                }
            }
 
        } else { // No need to dodge 0. Normal binary search.
            if (list[index] == target) {
                return index;
            } else if (list[index] < target) {
                first = index + 1;
            } else {
                last = index - 1;
            }
 
        }
        // index has been updated, no matter the branch.
        index = (first + last) / 2;
    }
 
    if (first > last) {
        return -1;
    }
    return index;
}*/
 
GSC_LOCALX_T gsc_get_from_ordered_pedigree_list(const gsc_PedigreeID target, 
                                                const GSC_LOCALX_T listLen, 
                                                const gsc_PedigreeID* list) {
    GSC_LOCALX_T first = 0, last = listLen - 1;
    GSC_LOCALX_T index = (first + last) / 2;
    while (list[index].id != target.id && first <= last) {
        if (list[index].id == GSC_NO_PEDIGREE.id) {
            int lookahead = 1;
            while(1) {
                if (index+lookahead <= last && list[index+lookahead].id != GSC_NO_PEDIGREE.id) {
                    if (list[index+lookahead].id == target.id) {
                        return index+lookahead;
                    } else if (list[index+lookahead].id < target.id) {
                        first = index+lookahead + 1;
                        break;
                    } else {
                        last = index - 1;
                        break;
                    }
                } else if (index-lookahead <= last && list[index-lookahead].id != GSC_NO_PEDIGREE.id) {
                    if (list[index-lookahead].id == target.id) {
                        return index-lookahead;
                    } else if (list[index-lookahead].id < target.id) {
                        first = index + 1;
                        break;
                    } else {
                        last = index-lookahead - 1;
                        break;
                    }
                }
                ++lookahead;
                if (index+lookahead <= last || index-lookahead >= first) {
                    // failed to find any nonzeros between first and last
                    return GSC_NA_LOCALX;
                }
            }
 
        } else { // No need to dodge 0. Normal binary search.
            if (list[index].id == target.id) {
                return index;
            } else if (list[index].id < target.id) {
                first = index + 1;
            } else {
                last = index - 1;
            }
 
        }
        // index has been updated, no matter the branch.
        index = (first + last) / 2;
    }
 
    if (first > last) {
        return GSC_NA_LOCALX;
    }
    return index;
}
 
size_t gsc_get_from_unordered_str_list(const char* target, 
                                       const size_t listLen, 
                                       const char** list) {
    for (size_t i = 0; i < listLen; ++i) {
        if (strcmp(list[i], target) == 0) {
            return i;
        }
    }
    return SIZE_MAX; // did not find a match.
}
 
size_t gsc_get_from_ordered_str_list(const char* target, 
                                     const size_t listLen, 
                                     const char** list) {
    size_t first = 0, last = listLen - 1;
    size_t index = (first + last) / 2;
    int comparison = strcmp(target,list[index]);
    while (comparison != 0 && first <= last) {
        if (comparison == 0) {
            return index;
        } else if (comparison < 0) {
            first = index + 1;
        } else {
            last = index - 1;
        }
 
        // index has been updated, no matter the branch.
        index = (first + last) / 2;
        comparison = strcmp(target, list[index]);
    }
 
    if (first > last) {
        return SIZE_MAX;
    }
    return index;
}
 
 
void gsc_shuffle_up_to(rnd_pcg_t* rng, 
                       void* sequence, 
                       const size_t item_size,
                       const size_t total_n, 
                       const size_t n_to_shuffle) {
    if (n_to_shuffle > 1) {
        
        size_t tmp_spot;
        void* tmp = &tmp_spot;
        if (item_size > sizeof(tmp_spot)) {
            tmp = gsc_malloc_wrap(item_size, GSC_TRUE);
        }
        
        size_t maxi = total_n > n_to_shuffle ? n_to_shuffle - 1 : total_n - 1;
        size_t i;
        for (i = 0; i <= maxi; ++i) {
            // items before i are already shuffled
            size_t j = i + rnd_pcg_range(rng,0,total_n - i - 1);
 
            // add the next chosen value to the end of the shuffle
            memcpy(&tmp,                   sequence + j*item_size, item_size);
            memcpy(sequence + j*item_size, sequence + i*item_size, item_size);
            memcpy(sequence + i*item_size, &tmp,                   item_size);
        }
        
        if (item_size > sizeof(tmp_spot)) {
            free(tmp);
        }
    }
}
 
static void gsc_set_names(gsc_AlleleMatrix* a, 
                          const char* prefix, 
                          const int suffix, 
                          const GSC_LOCALX_T from_index) {
    char sname[NAME_LENGTH];
    char format[NAME_LENGTH];
    if (prefix == NULL) {
        // make it an empty string instead, so it is not displayed as (null)
        prefix = "";
    }
    // use sname to save the number of digits to pad by:
    sprintf(sname, "%%0%dd", gsc_get_integer_digits(a->n_genotypes - from_index));  // Creates: %0[n]d
    sprintf(format, "%s%s", prefix, sname);
 
    int livingsuffix = suffix;
    ++livingsuffix;
    for (GSC_LOCALX_T i = from_index; i < a->n_genotypes; ++i) {
        // clear name if it's pre-existing
        if (a->names[i] != NULL) {
            GSC_FREE(a->names[i]);
        }
 
        // save new name
        sprintf(sname, format, livingsuffix);
        a->names[i] = gsc_malloc_wrap(sizeof(char) * (strlen(sname) + 1),GSC_TRUE);
        strcpy(a->names[i], sname);
 
        ++livingsuffix;
    }
}
 
gsc_LabelID gsc_create_new_label(gsc_SimData* d, const int setTo) {
    // Add new label default
    if (d->n_labels == 0) {
        d->label_ids = gsc_malloc_wrap(sizeof(gsc_LabelID) * 1,GSC_TRUE);
        d->label_ids[0] = (gsc_LabelID){.id=1};
 
        d->label_defaults = gsc_malloc_wrap(sizeof(int) * 1,GSC_TRUE);
        d->label_defaults[0] = setTo;
 
    } else if (d->n_labels > 0) {
 
        gsc_LabelID* new_label_ids;
        if (d->label_ids != NULL) {
            new_label_ids = gsc_malloc_wrap(sizeof(gsc_LabelID) * (d->n_labels + 1),GSC_TRUE);
            memcpy(new_label_ids,d->label_ids,sizeof(gsc_LabelID)*d->n_labels);
            new_label_ids[d->n_labels] = gsc_get_new_label_id(d);
            GSC_FREE(d->label_ids);
 
        } else { // d->label_ids == NULL
            // If the other labels do not have identifiers, they're corrupted and
            // deserve to be destroyed.
            new_label_ids = gsc_malloc_wrap(sizeof(gsc_LabelID) * 1,GSC_TRUE);
            d->n_labels = 0;
            new_label_ids[d->n_labels] = gsc_get_new_label_id(d);
        }
        d->label_ids = new_label_ids;
 
        int* new_label_defaults = gsc_malloc_wrap(sizeof(int) * (d->n_labels + 1),GSC_TRUE);
        if (d->label_defaults != NULL) {
            for (GSC_ID_T i = 0; i < d->n_labels; ++i) {
                new_label_defaults[i] = d->label_defaults[i];
            }
            GSC_FREE(d->label_defaults);
        } else if (d->n_labels > 0) {
            memset(new_label_defaults, 0, sizeof(int) * d->n_labels);
        }
        new_label_defaults[d->n_labels] = setTo;
        d->label_defaults = new_label_defaults;
 
    } else {
        fprintf(stderr, "Labels malformed; gsc_SimData may be corrupted\n");
        return (gsc_LabelID){.id=GSC_NA_ID};
    }
    d->n_labels += 1;
 
    // Set all values of that label to the default
    gsc_AlleleMatrix* m = d->m;
    int warned = GSC_FALSE;
    while (m != NULL) {
        // Do we need to destroy the extant label table? happens if label_ids were missing and we discarded them
        if (m->n_labels != d->n_labels - 1 && m->labels != NULL) {
            for (GSC_ID_T i = 0; i < m->n_labels; ++i) {
                GSC_FREE(m->labels[i]);
            }
            GSC_FREE(m->labels);
            m->labels = NULL;
        }
 
        m->n_labels = d->n_labels;
 
        // Consider the case when we need to expand the label list
        if (m->n_labels > 1 && m->labels != NULL) {
            GSC_ID_T newLabel = m->n_labels - 1;
 
            // Create label list
            int** oldLabelList = m->labels;
            m->labels = gsc_malloc_wrap(sizeof(int*) * m->n_labels,GSC_TRUE);
            for (GSC_ID_T i = 0; i < m->n_labels - 1; ++i) {
                m->labels[i] = oldLabelList[i];
            }
            m->labels[newLabel] = gsc_malloc_wrap(sizeof(int) * CONTIG_WIDTH,GSC_TRUE);
            GSC_FREE(oldLabelList);
 
            // Set labels
            if (setTo == 0) {
                memset(m->labels[newLabel], 0, sizeof(int) * CONTIG_WIDTH);
            } else {
                for (GSC_LOCALX_T i = 0; i < CONTIG_WIDTH; ++i) {
                    m->labels[newLabel][i] = setTo;
                }
            }
 
        // Consider the case we need to initialise the label list
        } else if (m->n_labels == 1 && m->labels == NULL) {
            // Create the label list
            m->labels = gsc_malloc_wrap(sizeof(int*) * 1,GSC_TRUE);
            m->labels[0] = gsc_malloc_wrap(sizeof(int) * CONTIG_WIDTH,GSC_TRUE);
 
            // Set labels
            if (setTo == 0) {
                memset(m->labels[0], 0, sizeof(int) * CONTIG_WIDTH);
            } else {
                for (GSC_LOCALX_T i = 0; i < CONTIG_WIDTH; ++i) {
                    m->labels[0][i] = setTo;
                }
            }
 
        } else if (!warned) {
            fprintf(stderr, "Unable to create new label for all genotypes; gsc_SimData may be corrupted\n");
            warned = GSC_TRUE;
        }
        
        m = m->next;
    }
    return d->label_ids[d->n_labels - 1];
}
 
void gsc_change_label_default(gsc_SimData* d, 
                              const gsc_LabelID whichLabel, 
                              const int newDefault) {
    GSC_ID_T labelIndex;
    if (whichLabel.id == GSC_NO_LABEL.id || (labelIndex = gsc_get_index_of_label(d, whichLabel)) == GSC_NA_IDX) {
        fprintf(stderr, "Nonexistent label %lu\n", (long unsigned int) whichLabel.id);
        return;
    }
    d->label_defaults[labelIndex] = newDefault;
}
 
void gsc_change_label_to(gsc_SimData* d, 
                         const gsc_GroupNum whichGroup, 
                         const gsc_LabelID whichLabel, 
                         const int setTo) {
    GSC_ID_T labelIndex;
    if (whichLabel.id == GSC_NO_LABEL.id || (labelIndex = gsc_get_index_of_label(d, whichLabel)) == GSC_NA_IDX) {
        fprintf(stderr, "Nonexistent label %lu\n", (long unsigned int) whichLabel.id);
        return;
    }
    // Risks: if m->labels or m->labels[i] don't exist for labels where they should,
    // will get some out of bounds accesses.
 
    gsc_AlleleMatrix* m = d->m;
    if (whichGroup.num != GSC_NO_GROUP.num) { // set the labels of group members
        while (m != NULL) {
 
            for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                if (m->groups[i].num == whichGroup.num) {
                    m->labels[labelIndex][i] = setTo;
                }
            }
            m = m->next;
 
        }
 
    } else { // whichGroup == 0 so set the labels of all genotypes
        while (m != NULL) {
 
            if (setTo == 0) {
                memset(m->labels[labelIndex], 0, sizeof(int) * m->n_genotypes);
            } else {
                for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                    m->labels[labelIndex][i] = setTo;
                }
            }
            m = m->next;
        }
    }
}
 
void gsc_change_label_by_amount(gsc_SimData* d, 
                                const gsc_GroupNum whichGroup, 
                                const gsc_LabelID whichLabel, 
                                const int byValue) {
    GSC_ID_T labelIndex;
    if (whichLabel.id == GSC_NO_LABEL.id || (labelIndex = gsc_get_index_of_label(d, whichLabel)) == GSC_NA_IDX) {
        fprintf(stderr, "Nonexistent label %lu\n", (long unsigned int) whichLabel.id);
        return;
    }
    // Risks: if m->labels or m->labels[i] don't exist for labels where they should,
    // will get some out of bounds accesses.
 
    gsc_AlleleMatrix* m = d->m;
    if (whichGroup.num != GSC_NO_GROUP.num) { // set the labels of group members
        while (m != NULL) {
 
            for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                if (m->groups[i].num == whichGroup.num) {
                    m->labels[labelIndex][i] += byValue;
                }
            }
            m = m->next;
        }
 
    } else { // whichGroup == 0 so set the labels of all genotypes
        while (m != NULL) {
 
            for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                m->labels[labelIndex][i] += byValue;
            }
            m = m->next;
        }
    }
 
}
 
void gsc_change_label_to_values(gsc_SimData* d, 
                                const gsc_GroupNum whichGroup, 
                                const GSC_GLOBALX_T startIndex, 
                                const gsc_LabelID whichLabel,
                                const size_t n_values, 
                                const int* values) {
    GSC_ID_T labelIndex;
    if (whichLabel.id == GSC_NO_LABEL.id || (labelIndex = gsc_get_index_of_label(d, whichLabel)) == GSC_NA_IDX) {
        fprintf(stderr, "Nonexistent label %lu\n", (long unsigned int) whichLabel.id);
        return;
    }
 
    gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T currentIndex = 0;
    if (whichGroup.num != GSC_NO_GROUP.num) { // set the labels of group members
        // First scan through to find firstIndex
        while (m != NULL) {
 
            for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                if (m->groups[i].num == whichGroup.num) {
                    // Update label if it is between startIndex and startIndex + n_values
                    if (currentIndex >= startIndex) {
                        m->labels[labelIndex][i] = values[currentIndex - startIndex];
                    }
                    currentIndex++;
                    if (currentIndex > startIndex && currentIndex - startIndex >= n_values) {
                        return;
                    }
                }
            }
            m = m->next;
        }
 
    } else { // whichGroup == 0 so set the labels of all genotypes
        while (m != NULL) {
 
            for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                // Update label if it is between startIndex and startIndex + n_values
                if (currentIndex >= startIndex) {
                    m->labels[labelIndex][i] = values[currentIndex - startIndex];
                }
                currentIndex++;
                if (currentIndex > startIndex && currentIndex - startIndex >= n_values) {
                    return;
                }
            }
            m = m->next;
        }
    }
}
 
void gsc_change_names_to_values(gsc_SimData* d, 
                                const gsc_GroupNum whichGroup, 
                                const GSC_GLOBALX_T startIndex, 
                                const size_t n_values, 
                                const char** values) {
    // this will be much improved once we can hash our names.
 
    gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T currentIndex = 0;
    if (whichGroup.num != GSC_NO_GROUP.num) { // set the names of group members
        // First scan through to find firstIndex
        while (m != NULL) {
 
            for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                if (m->groups[i].num == whichGroup.num) {
                    // Update name if index is between startIndex and startIndex + n_values
                    if (currentIndex >= startIndex) {
                        // clear name if it's pre-existing
                        if (m->names[i] != NULL) {
                            GSC_FREE(m->names[i]);
                        }
 
                        // save new name
                        const GSC_GLOBALX_T whichName = currentIndex - startIndex;
                        m->names[i] = gsc_malloc_wrap(sizeof(char) * (strlen(values[whichName]) + 1),GSC_TRUE);
                        strcpy(m->names[i], values[whichName]);
                    }
                    currentIndex++;
                    if (currentIndex > n_values) {
                        return;
                    }
                }
            }
            m = m->next;
 
        }
 
    } else { // whichGroup == 0 so set the names of all genotypes
        while (m != NULL) {
 
            for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
                // Update name if it is between startIndex and startIndex + n_values
                if (currentIndex >= startIndex) {
                    // clear name if it's pre-existing
                    if (m->names[i] != NULL) {
                        GSC_FREE(m->names[i]);
                    }
 
                    // save new name
                    const GSC_GLOBALX_T whichName = currentIndex - startIndex;
                    const int nameLen = strlen(values[whichName]);
                    m->names[i] = gsc_malloc_wrap(sizeof(char) * (nameLen + 1),GSC_TRUE);
                    strncpy(m->names[i], values[whichName], nameLen);
                }
                currentIndex++;
                if (currentIndex > n_values) {
                    return;
                }
            }
            m = m->next;
 
        }
    }
}
 
void gsc_change_allele_symbol(gsc_SimData* d, 
                              const char* which_marker, 
                              const char from, 
                              const char to) {
    GSC_GENOLEN_T nmarkers = 0;
    GSC_GLOBALX_T ngenos = 0;
    unsigned int nalleles = 0;
 
    GSC_GENOLEN_T markeri;
    if (which_marker == NULL) {
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d,NO_GROUP);
        gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(&it);
 
        while (IS_VALID_LOCATION(loc)) {
            for (GSC_GENOLEN_T m = 0; m < d->genome.n_markers; ++m) {
                if (from == loc.localAM->alleles[loc.localPos][m << 1]) {
                    loc.localAM->alleles[loc.localPos][m << 1] = to;
                    ++nalleles;
                    ++ngenos;
                }
                if (from == loc.localAM->alleles[loc.localPos][(m << 1) + 1]) {
                    loc.localAM->alleles[loc.localPos][(m << 1) + 1] = to;
                    ++nalleles;
                    if (loc.localAM->alleles[loc.localPos][m << 1] != 
                            loc.localAM->alleles[loc.localPos][(m << 1) + 1]) {
                        ++ngenos;
                    }
                }
            }
 
            loc = gsc_next_forwards(&it);
        }
 
        gsc_delete_bidirectional_iter(&it);
 
 
    } else if (gsc_get_index_of_genetic_marker(which_marker, d->genome, &markeri)) {
        nmarkers = 1;
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d,NO_GROUP);
        gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(&it);
        while (IS_VALID_LOCATION(loc)) {
            if (from == loc.localAM->alleles[loc.localPos][markeri << 1]) {
                loc.localAM->alleles[loc.localPos][markeri << 1] = to;
                ++nalleles;
                ++ngenos;
            }
            if (from == loc.localAM->alleles[loc.localPos][(markeri << 1) + 1]) {
                loc.localAM->alleles[loc.localPos][(markeri << 1) + 1] = to;
                ++nalleles;
                if (loc.localAM->alleles[loc.localPos][markeri << 1] != 
                        loc.localAM->alleles[loc.localPos][(markeri << 1) + 1]) {
                    ++ngenos;
                }
            }
 
            loc = gsc_next_forwards(&it);
        }
 
        gsc_delete_bidirectional_iter(&it);
 
    } else {
        nmarkers = 0;
        ngenos = 0;
    }
 
    printf("Changed allele %c to %c %lu times across %lu markers and %lu genotypes\n", 
           from, to, (long unsigned int)nalleles, (long unsigned int)nmarkers, (long unsigned int)ngenos);
}
 
_Bool gsc_change_eff_set_centres_to_values(gsc_SimData* d,
                                           const gsc_EffectID effset,
                                           const GSC_GENOLEN_T n_values,
                                           const double* values) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effset);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effset.id);
        return 0;
    }
    
    if (n_values != d->e[effIndex].n_markers) {
        fprintf(stderr,"Cannot use these values as marker effect centres because the number of values is not equal to the number of markers in the effect set\n");
        return 0;
    }
 
    if (d->e[effIndex].centre == NULL) {
        d->e[effIndex].centre = gsc_malloc_wrap(sizeof(*d->e[effIndex].centre)*d->e[effIndex].n_markers, GSC_TRUE);
    }
    memcpy(d->e[effIndex].centre, values, sizeof(*d->e[effIndex].centre)*d->e[effIndex].n_markers);
    return 1;
}
 
GSC_GENOLEN_T gsc_change_eff_set_centre_of_markers(gsc_SimData* d,
                                                   const gsc_EffectID effset,
                                                   const GSC_GENOLEN_T n_markers,
                                                   const char** marker_names,
                                                   const double* centres) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effset);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effset.id);
        return 0;
    }
    
    gsc_MarkerEffects* e = d->e + effIndex;
    if (e->centre == NULL) {
        e->centre = gsc_malloc_wrap(sizeof(*e->centre)*e->n_markers, GSC_TRUE);
        for (GSC_GENOLEN_T i = 0; i < e->n_markers; ++i) {
            e->centre[i] = 0.;
        }
    }
    
    GSC_GENOLEN_T successes = 0;
    for (GSC_GENOLEN_T ix = 0; ix < n_markers; ++ix) {
        GSC_GENOLEN_T markerix;
        if (gsc_get_index_of_genetic_marker(marker_names[ix], d->genome, &markerix)) {
            ++successes;
        } else {
            fprintf(stderr,"Could not find marker named %s in the list of tracked markers\n", marker_names[ix]);
            continue;
        }
        e->centre[markerix] = centres[ix]; // the significant line
    }
    return successes;
}
 
GSC_GENOLEN_T gsc_change_eff_set_centre_of_allele_count(gsc_SimData* d,
                                                        const gsc_EffectID effset,
                                                        const GSC_GENOLEN_T n_markers,
                                                        const char** marker_names,
                                                        const double* centres,
                                                        const char allele,
                                                        const _Bool reset_centres) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effset);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effset.id);
        return 0;
    }
    
    gsc_MarkerEffects* e = d->e + effIndex;
    if (e->centre == NULL) {
        e->centre = gsc_malloc_wrap(sizeof(*e->centre)*e->n_markers, GSC_TRUE);
        for (GSC_GENOLEN_T i = 0; i < e->n_markers; ++i) {
            e->centre[i] = 0.;
        }
    } else if (reset_centres) {
        for (GSC_GENOLEN_T i = 0; i < e->n_markers; ++i) {
            e->centre[i] = 0.;
        }
    }
    
    GSC_GENOLEN_T successes = 0;
    for (GSC_GENOLEN_T ix = 0; ix < n_markers; ++ix) {
        GSC_GENOLEN_T markerix;
        if (gsc_get_index_of_genetic_marker(marker_names[ix], d->genome, &markerix)) {
            // We have the marker. Let's find the effect of this allele
            _Bool found = 0;
            for (GSC_GENOLEN_T a = ((markerix > 0) ? e->cumn_alleles[markerix-1] : 0); 
                    a < e->cumn_alleles[markerix]; ++a) {
                if (e->allele[a] == allele) {
                    found = 1;
                    
                    // the significant lines:
                    double mcentre = centres[ix] * e->eff[a];
                    e->centre[markerix] = reset_centres ? mcentre : mcentre + e->centre[markerix]; 
                    break;
                }
            }
            if (!found) {
                fprintf(stderr,"Could not find effect value for allele %c at marker %s\n", allele, marker_names[ix]);
            } else {
                ++successes;
            }
        } else {
            fprintf(stderr,"Could not find marker named %s in the list of tracked markers\n", marker_names[ix]);
            continue;
        }
    }
    return successes;
}
 
int gsc_get_integer_digits(const int i) {
    int digits = 0, ii = i;
    while (ii != 0) {
        ii = ii / 10;
        digits ++;
    }
    return digits;
}
 
static int gsc_helper_descending_pdouble_comparer(const void* pp0, const void* pp1) {
    double d0 = **(double **)pp0;
    double d1 = **(double **)pp1;
    if (d0 > d1) {
        return -1;
    } else {
        return (d0 < d1); // 0 if equal, 1 if d0 is smaller
    }
}
 
static int gsc_helper_ascending_double_comparer(const void* pp0, const void* pp1) {
    double d0 = *(double *)pp0;
    double d1 = *(double *)pp1;
    if (d0 < d1) {
        return -1;
    } else {
        return (d0 > d1); // 0 if equal, 1 if d0 is smaller
    }
}
 
static int gsc_helper_ascending_pdouble_comparer(const void* pp0, const void* pp1) {
    double d0 = **(double **)pp0;
    double d1 = **(double **)pp1;
    if (d0 < d1) {
        return -1;
    } else {
        return (d0 > d1); // 0 if equal, 1 if d0 is smaller
    }
}
 
static int gsc_helper_indirect_alphabetical_str_comparer(const void* p0, const void* p1) {
    char* str1 = **(char***)p0;
    char* str2 = **(char***)p1;
    return strcmp(str1,str2);
}
 
static int gsc_helper_mapfileunit_ascending_chr_comparer(const void* p0, const void* p1) {
    struct gsc_MapfileUnit s0 = *(struct gsc_MapfileUnit*)p0;
    struct gsc_MapfileUnit s1 = *(struct gsc_MapfileUnit*)p1;
    //return (s0.chr < s1.chr) ? -1 : (s0.chr > s1.chr);
    return strcmp(s0.chr, s1.chr);
}
 
static int gsc_helper_mapfileunit_ascending_d_comparer(const void* p0, const void* p1) {
    struct gsc_MapfileUnit s0 = *(struct gsc_MapfileUnit*)p0;
    struct gsc_MapfileUnit s1 = *(struct gsc_MapfileUnit*)p1;
    return (s0.pos < s1.pos) ? -1 : (s0.pos > s1.pos);
}
 
static int gsc_helper_effectfileunit_ascending_mix_comparer(const void* p0, const void* p1) {
    struct gsc_EffectfileUnit s0 = *(struct gsc_EffectfileUnit*)p0;
    struct gsc_EffectfileUnit s1 = *(struct gsc_EffectfileUnit*)p1;
    return (s0.markerix < s1.markerix) ? -1 : (s0.markerix > s1.markerix);
}
 
void gsc_move_genotype(gsc_GenoLocation from, 
                       gsc_GenoLocation to, 
                       int* label_defaults) {
    if (to.localAM == from.localAM && to.localPos == from.localPos) {
        return;
    }
    if (to.localAM->groups[to.localPos].num != GSC_NO_GROUP.num) {
        fprintf(stderr,"In moving a genotype from %p:%lu to %p:%lu, the genotype at %p:%lu will be overwritten\n",
                from.localAM, (long unsigned int)from.localPos, to.localAM, (long unsigned int)to.localPos, 
                to.localAM, (long unsigned int)to.localPos);
        --to.localAM->n_genotypes;
    }
    to.localAM->alleles[to.localPos] = from.localAM->alleles[from.localPos];
    from.localAM->alleles[from.localPos] = NULL;
 
    to.localAM->names[to.localPos] = from.localAM->names[from.localPos];
    from.localAM->names[from.localPos] = NULL;
 
    to.localAM->ids[to.localPos] = from.localAM->ids[from.localPos];
    from.localAM->ids[from.localPos] = GSC_NO_PEDIGREE;
 
    to.localAM->pedigrees[0][to.localPos] = from.localAM->pedigrees[0][from.localPos];
    from.localAM->pedigrees[0][from.localPos] = GSC_NO_PEDIGREE;
    to.localAM->pedigrees[1][to.localPos] = from.localAM->pedigrees[1][from.localPos];
    from.localAM->pedigrees[1][from.localPos] = GSC_NO_PEDIGREE;
 
    to.localAM->groups[to.localPos] = from.localAM->groups[from.localPos];
    from.localAM->groups[from.localPos] = GSC_NO_GROUP;
 
    if (to.localAM->n_labels != from.localAM->n_labels) {
        fprintf(stderr,"Origin and destination when copying genotype do not have the same number of custom"
                       " labels (n_labels). The genotype now at %p:%lu will have lost its label data\n", 
                       to.localAM, (long unsigned int)to.localPos);
    } else if (to.localAM->n_labels != 0 && label_defaults == NULL) {
        fprintf(stderr,"Label defaults must be supplied to gsc_move_genotypes or there is risk of "
                       "corrupted label values in further use of the simulation");
    } else {
        for (GSC_ID_T i = 0; i < to.localAM->n_labels; ++i) {
            to.localAM->labels[i][to.localPos] = from.localAM->labels[i][from.localPos];
            from.localAM->labels[i][from.localPos] = label_defaults[i];
        }
    }
 
    if (from.localAM != to.localAM) {
        --from.localAM->n_genotypes;
        ++to.localAM->n_genotypes;
    }
}
 
static gsc_GenoLocation gsc_nextgappy_valid_pos(struct gsc_GappyIterator* it) {
    if (it->cursor.localAM == NULL) {
        it->cursor = GSC_INVALID_GENO_LOCATION;
    } else if (it->cursor.localPos >= CONTIG_WIDTH) {
        it->cursor.localPos = 0;
        it->cursor.localAM = it->cursor.localAM->next;
        ++it->cursorAMIndex;
        if (it->cursor.localAM == NULL) {
            it->cursor = GSC_INVALID_GENO_LOCATION;
        }
    }
    return it->cursor;
}
 
static gsc_GenoLocation gsc_nextgappy_get_gap(struct gsc_GappyIterator* it) {
    if (!GSC_IS_VALID_LOCATION(gsc_nextgappy_valid_pos(it))) {
        return GSC_INVALID_GENO_LOCATION;
    }
 
    while (it->cursor.localAM->groups[it->cursor.localPos].num != GSC_NO_GROUP.num) {
 
        // Trusts that n_genotypes is correct.
        if (it->cursor.localAM->n_genotypes == CONTIG_WIDTH) { // work-saver: skip this gsc_AlleleMatrix if it is already known to be full.
            it->cursor.localAM = it->cursor.localAM->next;
            ++it->cursorAMIndex;
        } else {
            ++it->cursor.localPos;
        }
 
        if (!GSC_IS_VALID_LOCATION(gsc_nextgappy_valid_pos(it))) {
            return GSC_INVALID_GENO_LOCATION;
        }
    }
 
    return it->cursor;
}
 
static gsc_GenoLocation gsc_nextgappy_get_nongap(struct gsc_GappyIterator* it) {
    if (!GSC_IS_VALID_LOCATION(gsc_nextgappy_valid_pos(it))) {
        return GSC_INVALID_GENO_LOCATION;
    }
 
    while (it->cursor.localAM->groups[it->cursor.localPos].num == GSC_NO_GROUP.num) {
        ++it->cursor.localPos;
        if (!GSC_IS_VALID_LOCATION(gsc_nextgappy_valid_pos(it))) {
            return GSC_INVALID_GENO_LOCATION;
        }
    }
 
    return it->cursor;
}
 
 
void gsc_condense_allele_matrix(gsc_SimData* d) {
    // Find the first gap
    struct gsc_GappyIterator filler = {.cursor=(gsc_GenoLocation){.localAM=d->m, .localPos=0}, 
                                       .cursorAMIndex=0};
    gsc_nextgappy_get_gap(&filler);
 
    if (!GSC_IS_VALID_LOCATION(filler.cursor)) {
        return; // no gaps found
    }
 
    struct gsc_GappyIterator checker = filler; // copy filler
    ++checker.cursor.localPos;
    gsc_nextgappy_get_nongap(&checker);
 
    // Shuffle all candidates back
    while (GSC_IS_VALID_LOCATION(filler.cursor) && GSC_IS_VALID_LOCATION(checker.cursor)) {
        gsc_move_genotype(checker.cursor, filler.cursor, d->label_defaults);
 
        ++filler.cursor.localPos;
        gsc_nextgappy_get_gap(&filler);
 
        ++checker.cursor.localPos;
        gsc_nextgappy_get_nongap(&checker);
    }
 
    // Then, free any other pre-allocated space
    while (GSC_IS_VALID_LOCATION(filler.cursor)) {
        if (filler.cursor.localAM->n_genotypes == 0) {
            // no genotypes after this point
            AlleleMatrix* previous = gsc_get_nth_AlleleMatrix(d->m, filler.cursorAMIndex - 1);
            if (previous != NULL) { 
                previous->next = NULL; 
                gsc_delete_allele_matrix(filler.cursor.localAM);
            }     
            filler.cursor.localAM = NULL; 
            
        } else {
            // If this gap has allocated space, clear it.
            if (gsc_get_alleles(filler.cursor) != NULL) {
                GSC_FREE(gsc_get_alleles(filler.cursor));
                filler.cursor.localAM->alleles[filler.cursor.localPos] = NULL;
            }
            if (gsc_get_name(filler.cursor) != NULL) {
                GSC_FREE(gsc_get_name(filler.cursor));
                filler.cursor.localAM->names[filler.cursor.localPos] = NULL;
            }
            filler.cursor.localAM->ids[filler.cursor.localPos] = GSC_NO_PEDIGREE;
            filler.cursor.localAM->pedigrees[0][filler.cursor.localPos] = GSC_NO_PEDIGREE;
            filler.cursor.localAM->pedigrees[1][filler.cursor.localPos] = GSC_NO_PEDIGREE;
            filler.cursor.localAM->groups[filler.cursor.localPos] = GSC_NO_GROUP;
 
            ++filler.cursor.localPos;
            gsc_nextgappy_get_gap(&filler);
        }
    }
}
 
 
 
/*----------------------------------Locators---------------------------------*/
 
 
gsc_BidirectionalIterator gsc_create_bidirectional_iter(gsc_SimData* d, 
                                                        const gsc_GroupNum group) {
    return gsc_create_bidirectional_iter_fromAM(d->m, group);
}
 
gsc_BidirectionalIterator gsc_create_bidirectional_iter_fromAM(gsc_AlleleMatrix* am, 
                                                               const gsc_GroupNum group) {
    return (gsc_BidirectionalIterator) {
        .am = am,
        .group = group,
        .localPos = GSC_NA_LOCALX,
 
        .cachedAM = am,
        .cachedAMIndex = 0,
 
        .atStart = 0,
        .atEnd = 0
    };
}
 
gsc_RandomAccessIterator gsc_create_randomaccess_iter( gsc_SimData* d, const gsc_GroupNum group) {
    GSC_LOCALX_T first = 0;
    gsc_AlleleMatrix* firstAM = d->m;
    _Bool anyExist = 1;
 
    // Want to know:
    // - is this group empty? (randomAccess should know if group size is 0)
    // - what is the first genotype index in this group?
 
    if (firstAM == NULL) {
        return (gsc_RandomAccessIterator) {
            .d = d,
            .group = group,
 
            .largestCached = 0,
            .groupSize = 0, // NA represents unknown, 0 represents empty
            .cacheSize = 0,
            .cache = NULL
        };
 
    } else if (group.num == GSC_NO_GROUP.num) { // scanning all genotypes
        while (firstAM->n_genotypes == 0) {
            if (firstAM->next == NULL) {
                // gsc_SimData is empty. Nowhere to go.
                anyExist = 0;
            } else { // Keep moving forwards through the list. Not polite enough to clean up the blank AM.
                firstAM = firstAM->next;
            }
        }
 
    } else { // scanning a specific group
        _Bool exitNow = 0;
        while (!exitNow) {
 
            // Set first, firstAM, firstAMIndex if appropriate
            for (GSC_LOCALX_T i = 0; i < firstAM->n_genotypes; ++i) {
                if (firstAM->groups[i].num == group.num) {
                    first = i;
                    exitNow = 1;
                    break;
                }
            }
 
            // Move along and set anyExist if appropriate
            if (!exitNow) {
                firstAM = firstAM->next;
                if (firstAM == NULL) {
                    anyExist = 0;
                    exitNow = 1;
                }
            }
        }
    }
 
    gsc_GenoLocation* cache = NULL;
    GSC_GLOBALX_T cacheSize = 0;
    if (anyExist) {
        cacheSize = 50;
        cache = gsc_malloc_wrap((sizeof(gsc_GenoLocation)*cacheSize),GSC_TRUE);
        cache[0] = (gsc_GenoLocation) {
                .localAM= firstAM,
                .localPos = first,
        };
        for (GSC_GLOBALX_T i = 1; i < cacheSize; ++i) {
            cache[i] = GSC_INVALID_GENO_LOCATION;
        }
 
    }
 
    return (gsc_RandomAccessIterator) {
        .d = d,
        .group = group,
 
        .largestCached = anyExist ? 0 : GSC_NA_GLOBALX,
        .groupSize = anyExist ? GSC_NA_GLOBALX : 0, // NA represents unknown, 0 represents empty
        .cacheSize = cacheSize,
        .cache = cache
    };
}
 
gsc_AlleleMatrix* gsc_get_nth_AlleleMatrix(gsc_AlleleMatrix* listStart, const unsigned int n) {
    unsigned int currentIndex = 0;
    gsc_AlleleMatrix* am = listStart;
    if (am == NULL) return NULL;
    while (currentIndex < n) {
        if (am->next == NULL) {
            return NULL;
        } else {
            am = am->next;
            currentIndex++;
        }
    }
    return am;
}
 
gsc_GenoLocation gsc_set_bidirectional_iter_to_start(gsc_BidirectionalIterator* it) {
    GSC_LOCALX_T first = 0;
    gsc_AlleleMatrix* firstAM = it->am;
    unsigned int firstAMIndex = 0;
    _Bool anyExist = 1;
 
    // Want to know:
    // - is this group empty? (iterator should know if it is at the end as well as at the start)
    // - what is the first genotype index in this group?
    if (firstAM == NULL) {
        return GSC_INVALID_GENO_LOCATION;
        
    } else if (it->group.num == GSC_NO_GROUP.num) {
        while (firstAM->n_genotypes == 0) {
            if (firstAM->next == NULL) {
                anyExist = 0; // gsc_SimData is empty.
 
            } else { // (Not polite enough to clean up the blank AM.)
                firstAM = firstAM->next;
                firstAMIndex++;
                // first += 0;
            }
        }
 
        // After this runs we have set firstAM, first, firstAMIndex, anyExist appropriately
 
    } else { // scanning a specific group
 
        _Bool exitNow = 0;
        while (!exitNow) {
 
            // Set first, firstAM, firstAMIndex if appropriate
            for (GSC_LOCALX_T i = 0; i < firstAM->n_genotypes; ++i) {
                if (firstAM->groups[i].num == it->group.num) {
                    first = i;
                    exitNow = 1;
                    break;
                }
            }
 
            // Move along and set anyExist if appropriate
            if (!exitNow) {
                firstAM = firstAM->next;
                firstAMIndex++;
                if (firstAM == NULL) {
                    first = GSC_NA_LOCALX;
                    anyExist = 0;
                    exitNow = 1;
                }
            }
        }
    }
 
    it->localPos = first;
    if (anyExist) {
        it->atStart = 1;
        it->atEnd = 0;
    } else { // fail immediately on all further accesses. The group is empty.
        it->atStart = 1;
        it->atEnd = 1;
    }
    it->cachedAM = firstAM;
    it->cachedAMIndex = firstAMIndex;
 
    return (gsc_GenoLocation) {
        .localAM = firstAM,
        .localPos = first
    };
}
 
gsc_GenoLocation gsc_set_bidirectional_iter_to_end(gsc_BidirectionalIterator* it) {
    GSC_LOCALX_T last = 0;
    gsc_AlleleMatrix* lastAM = it->am;
    unsigned int lastAMIndex = 0;
    _Bool anyExist = 1;
 
    // Want to know:
    // - is this group empty? (iterator should know if it is at the end as well as at the start)
    // - what is the first genotype index in this group?
 
    if (lastAM == NULL) {
        return GSC_INVALID_GENO_LOCATION;
        
    } if (it->group.num == GSC_NO_GROUP.num) {
        while (lastAM->next != NULL && lastAM->next->n_genotypes != 0) {
            lastAM = lastAM->next;
            lastAMIndex++;
        }
        if (lastAMIndex > 0 || lastAM->n_genotypes > 0) {
            last = lastAM->n_genotypes - 1;
        } else {
            anyExist = 0;
        }
 
    } else { // scanning a specific group
 
        // Find last AM
        while (lastAM->next != NULL && lastAM->next->n_genotypes != 0) {
            lastAM = lastAM->next;
            lastAMIndex++;
        }
 
        _Bool exitNow = 0;
        while (!exitNow) {
 
            // Set first, firstAM, firstAMIndex if appropriate
            for (GSC_LOCALX_T i = lastAM->n_genotypes - 1; i >= 0; --i) {
                if (lastAM->groups[i].num == it->group.num) {
                    last = i;
                    exitNow = 1;
                    break;
                }
            }
 
            // Move along and set anyExist if appropriate
            if (!exitNow) {
                --lastAMIndex;
                lastAM = gsc_get_nth_AlleleMatrix(it->am, lastAMIndex);
                if (lastAM->n_genotypes == 0) {
                    last = GSC_NA_LOCALX;
                    anyExist = 0;
                    exitNow = 1;
                }
            }
        }
    }
 
    it->localPos = last;
    if (anyExist) {
        it->atStart = 0;
        it->atEnd = 1;
    } else { // group is empty: fail immediately on any further accesses
        it->atStart = 1;
        it->atEnd = 1;
    }
    it->cachedAM = lastAM;
    it->cachedAMIndex = lastAMIndex;
 
    return (gsc_GenoLocation) {
        .localAM = lastAM,
        .localPos = last
    };
}
 
 
gsc_GenoLocation gsc_next_forwards(gsc_BidirectionalIterator* it) {
    if (it->localPos == GSC_NA_LOCALX) {
        return gsc_set_bidirectional_iter_to_start(it);
    }
 
    if (it->atEnd) { // || validate_bidirectional_cache(it) == GSC_FALSE) { // can't use this because what if our iterator user is modifying group allocations?
        return GSC_INVALID_GENO_LOCATION;
    }
 
    if (it->group.num == GSC_NO_GROUP.num) {
 
        // Search for the next value.
        if (it->localPos + 1 < it->cachedAM->n_genotypes) {
            // The next value is in the same gsc_AlleleMatrix
            it->localPos++;
            it->atStart = 0;
            return (gsc_GenoLocation) {
                .localAM = it->cachedAM,
                .localPos = it->localPos
            };
 
        } else {
            // The next value is in the next gsc_AlleleMatrix
            gsc_AlleleMatrix* nextAM = it->cachedAM;
            int nextAMIndex = it->cachedAMIndex;
            if (nextAM != NULL) {
                do {
                    nextAM = nextAM->next;
                    nextAMIndex++;
                } while (nextAM != NULL && nextAM->n_genotypes == 0);
            }
 
            if (nextAM == NULL) {
                // There is no further gsc_AlleleMatrix; we are at the end of the iterator.
                it->atEnd = 1;
                return GSC_INVALID_GENO_LOCATION;
            } else {
                it->cachedAM = nextAM;
                it->cachedAMIndex = nextAMIndex;
                it->localPos = 0;
                it->atStart = 0;
                return (gsc_GenoLocation) {
                    .localAM = it->cachedAM,
                    .localPos = 0
                };
            }
        }
 
    } else { // We are iterating through a specific group
 
        // Search for the next value
        while(1) {
            if (it->localPos + 1 < it->cachedAM->n_genotypes) {
                for (++it->localPos; it->localPos < it->cachedAM->n_genotypes; ++it->localPos) {
                    if (it->cachedAM->groups[it->localPos].num == it->group.num) {
                        it->atStart = 0;
                        return (gsc_GenoLocation) {
                            .localAM = it->cachedAM,
                            .localPos = it->localPos
                        };
                    }
                }
            }
 
            gsc_AlleleMatrix* nextAM = it->cachedAM;
            int nextAMIndex = it->cachedAMIndex;
            if (nextAM != NULL) {
                do {
                    nextAM = nextAM->next;
                    nextAMIndex++;
                } while (nextAM != NULL && nextAM->n_genotypes == 0);
            }
 
            if (nextAM == NULL) {
                // There is no further gsc_AlleleMatrix; we are at the end of the iterator.
                it->atEnd = 1;
                return GSC_INVALID_GENO_LOCATION;
            } else {
                it->cachedAM = nextAM;
                it->cachedAMIndex = nextAMIndex;
                it->localPos = 0;
                if (it->cachedAM->groups[it->localPos].num == it->group.num) {
                    it->atStart = 0;
                    return (gsc_GenoLocation) {
                        .localAM = it->cachedAM,
                        .localPos = it->localPos
                    };
                }
            }
        }
 
    }
}
 
 
gsc_GenoLocation gsc_next_backwards(gsc_BidirectionalIterator* it) {
    if (it->localPos == GSC_NA_LOCALX) {
        return gsc_set_bidirectional_iter_to_end(it);
    }
 
    if (it->atStart) { //|| validate_bidirectional_cache(it) == GSC_FALSE) {
        return GSC_INVALID_GENO_LOCATION;
    }
 
    if (it->group.num == GSC_NO_GROUP.num) {
 
        // Search for the previous value.
        if (it->localPos > 0) {
            // The previous value is in the same gsc_AlleleMatrix
            it->localPos--;
            it->atEnd = 0;
            return (gsc_GenoLocation) {
                .localAM = it->cachedAM,
                .localPos = it->localPos
            };
 
        } else {
            // The previous value is in the previous gsc_AlleleMatrix
            if (it->cachedAMIndex == 0) {
                it->atStart = 1;
                return GSC_INVALID_GENO_LOCATION;
            } else {
                gsc_AlleleMatrix* nextAM = it->cachedAM;
                int nextAMIndex = it->cachedAMIndex;
                if (nextAM != NULL) {
                    do {
                        nextAMIndex--;
                        nextAM = gsc_get_nth_AlleleMatrix(it->am, nextAMIndex);
                    } while (nextAM != NULL && nextAM->n_genotypes == 0);
                }
 
                if (nextAM == NULL) {
                    it->atStart = 1;
                    return GSC_INVALID_GENO_LOCATION;
                } else {
                    it->cachedAM = nextAM;
                    it->cachedAMIndex = nextAMIndex;
                    it->localPos = it->cachedAM->n_genotypes - 1;
                    it->atEnd = 0;
                    return (gsc_GenoLocation) {
                        .localAM = it->cachedAM,
                        .localPos = it->localPos
                    };
                }
            }
        }
 
    } else { // We are iterating through a specific group
 
        // Search for the next value
        while(1) {
            if (it->localPos > 0) {
                for (--it->localPos; it->localPos >= 0; --it->localPos) {
                    if (it->cachedAM->groups[it->localPos].num == it->group.num) {
                        it->atEnd = 0;
                        return (gsc_GenoLocation) {
                            .localAM = it->cachedAM,
                            .localPos = it->localPos
                        };
                    }
                }
            }
 
            if (it->cachedAMIndex == 0) {
                it->atStart = 1;
                it->localPos = 0;
                return GSC_INVALID_GENO_LOCATION;
            } else {
                gsc_AlleleMatrix* nextAM = it->cachedAM;
                int nextAMIndex = it->cachedAMIndex;
                if (nextAM != NULL) {
                    do {
                        nextAMIndex--;
                        nextAM = gsc_get_nth_AlleleMatrix(it->am, nextAMIndex);
                    } while (nextAM != NULL && nextAM->n_genotypes == 0);
                }
 
                if (nextAM == NULL) {
                    it->atStart = 1;
                    return GSC_INVALID_GENO_LOCATION;
                } else {
                    it->cachedAM = nextAM;
                    it->cachedAMIndex = nextAMIndex;
                    it->localPos = it->cachedAM->n_genotypes - 1;
                    if (it->cachedAM->groups[it->localPos].num == it->group.num) {
                        it->atEnd = 0;
                        return (gsc_GenoLocation) {
                            .localAM = it->cachedAM,
                            .localPos = it->localPos
                        };
                    }
                }
            }
        }
    }
}
 
 
gsc_GenoLocation gsc_next_get_nth(gsc_RandomAccessIterator* it, const GSC_GLOBALX_T n) {
    // Validity checks for a random access iterator: largestCached must exist,
    // is indeed cached and belongs to the same group
    /*if (it->largestCached == GSC_NA_GLOBALX || 
            (!GSC_IS_VALID_LOCATION(it->cache[it->largestCached]) &&
            (it->group.num == GSC_NO_GROUP.num || 
             it->group.num != gsc_get_group(it->cache[it->largestCached]).num))) {
        return GSC_INVALID_GENO_LOCATION;
    }*/
    
    // Step 0: Fail immediately if we know there aren't this many candidates in the group.
    if (it->groupSize != GSC_NA_GLOBALX && it->groupSize <= n) {
        return GSC_INVALID_GENO_LOCATION;
    }
    
    // Step 1: Check if we have it in the cache.
    if (n < it->cacheSize) {
        // 'n' is less than or equal to our current furthest cached group member.
 
        if (GSC_IS_VALID_LOCATION(it->cache[n])) { return it->cache[n]; }
        // Otherwise we do not have it cached, but we will enter it into the cache in the next section
    }
 
    // Step 2: The effort of actually finding the nth group member.
    if (it->group.num == GSC_NO_GROUP.num) {
        // Assuming all non-end gsc_AlleleMatrix are filled to CONTIG_WIDTH
        gsc_GenoLocation expectedLocation = {
            .localAM = gsc_get_nth_AlleleMatrix(it->d->m, n / CONTIG_WIDTH),
            .localPos = n % CONTIG_WIDTH
        };
        // Check n was not too large
        if (expectedLocation.localAM == NULL ||
                expectedLocation.localAM->n_genotypes <= expectedLocation.localPos) {
            return GSC_INVALID_GENO_LOCATION;
        }
        return expectedLocation;
 
    } else { // searching for a particular group
 
        gsc_AlleleMatrix* currentAM;
        GSC_GLOBALX_T groupN;
        GSC_LOCALX_T localPos;
 
        if (!GSC_IS_VALID_LOCATION(it->cache[it->largestCached])) {
            // Cache is invalid. You should throw out the iterator and replace with a new one.
            return GSC_INVALID_GENO_LOCATION;
        }
        
        // Search forwards from largestCached
        currentAM = it->cache[it->largestCached].localAM;
        groupN = it->largestCached;
        localPos = it->cache[it->largestCached].localPos + 1;
        
        while (1) {
            for (; localPos < currentAM->n_genotypes; ++localPos) {
                // If we found a group member, cache it and count upwards towards n
                if (currentAM->groups[localPos].num == it->group.num) {
                    it->largestCached = ++groupN;
                    
                    // Do we need to expand the cache to hold this?
                    if (it->largestCached >= it->cacheSize) {
                        GSC_GLOBALX_T newCacheSize = it->cacheSize;
                        if (it->cacheSize == 0) { 
                            newCacheSize = 25; 
                        } else {
                            newCacheSize = newCacheSize << 1;
                        }
                        gsc_GenoLocation* newCache = gsc_malloc_wrap(sizeof(gsc_GenoLocation)*newCacheSize,GSC_TRUE);
                        // initialise
                        memcpy(newCache, it->cache, sizeof(*newCache)*it->cacheSize);
                        for (GSC_GLOBALX_T i = it->cacheSize; i < newCacheSize; ++i) {
                            newCache[i] = GSC_INVALID_GENO_LOCATION;
                        }
                        // clean
                        GSC_FREE(it->cache);
                        it->cache = newCache;
                        it->cacheSize = newCacheSize;
                    }
                    
                    // Store this additional group member.
                    it->cache[groupN] = (gsc_GenoLocation) {
                        .localAM = currentAM,
                        .localPos = localPos
                    };
                    if (groupN == n) {
                        return it->cache[n];
                    }
                }
            }
 
            if (currentAM->next == NULL || currentAM->next->n_genotypes == 0) {
                // We are at the end of the iterator and have not found n
                it->groupSize = groupN + 1;
                return GSC_INVALID_GENO_LOCATION;
            } else {
                currentAM = currentAM->next;
                localPos = 0;
            }
 
        }
    }
 
}
 
char* gsc_get_name_of_id(const gsc_AlleleMatrix* start, const gsc_PedigreeID id) {
    if (id.id == GSC_NO_PEDIGREE.id) {
        fprintf(stderr, "Invalid ID %lu\n", (long unsigned int)id.id);
        return NULL;
    }
    if (start == NULL) {
        fprintf(stderr, "Invalid nonexistent allelematrix\n"); exit(1);
    }
    const gsc_AlleleMatrix* m = start;
 
    while (1) {
        // try to find our id. Does this AM potentially have the right range for it?
        // If we're not sure, because either of the endpoints does not have its ID tracked,
        // check anyway
        if (m->n_genotypes != 0 && (id.id >= m->ids[0].id || m->ids[0].id == GSC_NO_PEDIGREE.id) &&
                (id.id <= m->ids[m->n_genotypes - 1].id || m->ids[m->n_genotypes - 1].id == GSC_NO_PEDIGREE.id)) {
 
            GSC_LOCALX_T index = gsc_get_from_ordered_pedigree_list(id, m->n_genotypes, m->ids);
 
            if (index > m->n_genotypes) {
                // search failed
                if (m->next == NULL) {
                    fprintf(stderr, "Could not find the ID %lu: did you prematurely delete this genotype?\n", (long unsigned int)id.id);
                    return NULL;
                } else {
                    m = m->next;
                    continue;
                }
            }
 
            return m->names[index];
 
        }
 
        if (m->next == NULL) {
            fprintf(stderr, "Could not find the ID %lu: did you prematurely delete this genotype?\n", (long unsigned int)id.id);
            return NULL;
        } else {
            m = m->next;
        }
    }
}
 
int gsc_get_parents_of_id(const gsc_AlleleMatrix* start, 
                          const gsc_PedigreeID id, 
                          gsc_PedigreeID output[static 2]) {
    if (id.id == GSC_NO_PEDIGREE.id) {
        return 1;
    }
    if (start == NULL) {
        fprintf(stderr, "Invalid nonexistent allelematrix\n"); exit(1);
    }
    const gsc_AlleleMatrix* m = start;
    while (1) {
        // try to find our id. Does this AM have the right range for it?
        if (m->n_genotypes != 0 && id.id >= m->ids[0].id && id.id <= m->ids[m->n_genotypes - 1].id) {
            // perform binary search to find the exact index.
            GSC_LOCALX_T index = gsc_get_from_ordered_pedigree_list(id, m->n_genotypes, m->ids);
 
            if (index == GSC_NA_LOCALX) {
                // search failed
                /*if (m->next == NULL) {
                    fprintf(stderr, "Unable to locate ID %d in simulation memory (genotype has likely been deleted): pedigree past this point cannot be determined\n", id.id);
                    return 2;
                } else {
                    m = m->next;
                }*/
                continue;
            } else {
 
                if (m->pedigrees[0][index].id != GSC_NO_PEDIGREE.id || m->pedigrees[1][index].id != GSC_NO_PEDIGREE.id) {
                    output[0] = m->pedigrees[0][index];
                    output[1] = m->pedigrees[1][index];
                    return 0;
                }
                return 1; // if neither parent's id is known
            }
 
        }
 
        if (m->next == NULL) {
            fprintf(stderr, "Unable to locate ID %lu in simulation memory (genotype has likely been deleted): pedigree past this point cannot be determined\n", (long unsigned int)id.id);
            return 2;
        } else {
            m = m->next;
        }
    }
}
 
void gsc_get_ids_of_names(const gsc_AlleleMatrix* start, 
                          const size_t n_names, 
                          const char** names, 
                          gsc_PedigreeID* output) {
    if (start == NULL || (start->n_genotypes <= 0 && start->next == NULL)) {
        fprintf(stderr,"Invalid start parameter: gsc_AlleleMatrix* `start` must exist\n");
        return;
    }
    if (n_names < 1) {
        fprintf(stderr,"Invalid n_names parameter: Search list length must be positive\n");
        return;
    }
 
    _Bool found;
    const gsc_AlleleMatrix* m;
 
    for (size_t i = 0; i < n_names; ++i) {
        found = 0;
        output[i] = GSC_NO_PEDIGREE;
        m = start;
        while (1) {
            // try to identify the name in this AM
            for (GSC_LOCALX_T j = 0; j < m->n_genotypes; ++j) {
                if (strcmp(m->names[j], names[i]) == 0) {
                    found = 1;
                    output[i] = m->ids[j];
                    break;
                }
            }
 
            if (found) {
                break;
            }
            if ((m = m->next) == NULL) {
                fprintf(stderr, "Didn't find the name %s\n", names[i]);
            }
        }
    }
}
 
GSC_GLOBALX_T gsc_get_index_of_child(const gsc_AlleleMatrix* start, 
                           const gsc_PedigreeID parent1id, 
                           const gsc_PedigreeID parent2id) {
    if (start == NULL || (start->n_genotypes <= 0 && start->next == NULL)) {
        fprintf(stderr,"Invalid start parameter: gsc_AlleleMatrix* `start` must exist\n");
        return GSC_NA_GLOBALX;
    }
    const gsc_AlleleMatrix* m = start;
    GSC_GLOBALX_T total_j = 0;
 
    while (1) {
        // try to identify the child in this AM
        for (GSC_LOCALX_T j = 0; j < m->n_genotypes; ++j, ++total_j) {
            if ((parent1id.id == m->pedigrees[0][j].id && parent2id.id == m->pedigrees[1][j].id) ||
                    (parent1id.id == m->pedigrees[1][j].id && parent2id.id == m->pedigrees[0][j].id)) {
                return total_j;
            }
        }
 
        if ((m = m->next) == NULL) {
            fprintf(stderr, "Didn't find the child of %lu & %lu\n", 
                    (long unsigned int)parent1id.id, (long unsigned int)parent2id.id);
            return GSC_NA_GLOBALX;
        }
    }
}
 
GSC_GLOBALX_T gsc_get_index_of_name(const gsc_AlleleMatrix* start, const char* name) {
    if (name == NULL) {
        return GSC_NA_GLOBALX;
    }
    if (start == NULL || (start->n_genotypes <= 0 && start->next == NULL)) {
        fprintf(stderr,"Invalid start parameter: gsc_AlleleMatrix* `start` must exist\n");
        return GSC_NA_GLOBALX;
    }
    const gsc_AlleleMatrix* m = start;
    GSC_GLOBALX_T total_j = 0;
 
    while (1) {
        // try to identify the child in this AM
        for (GSC_LOCALX_T j = 0; j < m->n_genotypes; ++j, ++total_j) {
            if (m->names[j] != NULL && strcmp(m->names[j], name) == 0) {
                return total_j;
            }
        }
 
        if ((m = m->next) == NULL) {
            fprintf(stderr, "Didn't find the name %s\n", name);
            return GSC_NA_GLOBALX;
        }
    }
}
 
gsc_PedigreeID gsc_get_id_of_index(const gsc_AlleleMatrix* start, 
                                   const GSC_GLOBALX_T index) {
    if (start == NULL) {
        fprintf(stderr,"Invalid start parameter: gsc_AlleleMatrix* `start` must exist\n");
        return GSC_NO_PEDIGREE;
    }
    const gsc_AlleleMatrix* m = start;
    GSC_GLOBALX_T total_j = 0;
 
    while (1) {
        if (total_j == index) {
            return m->ids[0];
        } else if (total_j < index && total_j + m->n_genotypes > index) {
            return m->ids[index - total_j];
        }
        total_j += m->n_genotypes;
 
        if ((m = m->next) == NULL) {
            fprintf(stderr, "Didn't find the index %lu\n", (long unsigned int) index);
            return GSC_NO_PEDIGREE;
        }
    }
}
 
char* gsc_get_genes_of_index(const gsc_AlleleMatrix* start, 
                             const GSC_GLOBALX_T index) {
    if (start == NULL) {
        fprintf(stderr, "Invalid nonexistent allelematrix\n");
        return NULL;
    }
    const gsc_AlleleMatrix* m = start;
    GSC_GLOBALX_T total_j = 0;
 
    while (1) {
        if (total_j == index) {
            return m->alleles[0];
        } else if (total_j < index && total_j + m->n_genotypes > index) {
            return m->alleles[index - total_j];
        }
        total_j += m->n_genotypes;
 
        if ((m = m->next) == NULL) {
            fprintf(stderr, "Didn't find the index %lu\n", (long unsigned int) index);
            return NULL;
        }
    }
}
 
 
 
/*-----------------------------------Groups----------------------------------*/
 
gsc_GroupNum gsc_combine_groups(gsc_SimData* d, 
                                const size_t list_len, 
                                const gsc_GroupNum* grouplist) {
 
    // Find the first group in the list that exists. In most use cases this will be the
    // first group in the list, so not too much of a performance penalty.
    gsc_GroupNum outGroup = GSC_NO_GROUP;
    size_t i = 0;
    for (; i < list_len; ++i) {
        gsc_GroupNum candidate = grouplist[i];
        gsc_BidirectionalIterator testit = gsc_create_bidirectional_iter(d,candidate);
        gsc_GenoLocation testloc = gsc_next_forwards(&testit);
        gsc_delete_bidirectional_iter(&testit);
        if (GSC_IS_VALID_LOCATION(testloc)) {
            outGroup = candidate;
            break;
        }
    }
 
    int remaininglistlen = list_len - i;
    if (remaininglistlen < 2) {
        return outGroup;
    } else if (remaininglistlen == 2) {
        if (grouplist[i].num == grouplist[i+1].num) {
            return outGroup;
        }
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d,grouplist[i+1]);
        gsc_GenoLocation loc = gsc_next_forwards(&it);
        int anyFound = GSC_IS_VALID_LOCATION(loc);
 
        while (GSC_IS_VALID_LOCATION(loc)) {
            gsc_set_group(loc,outGroup);
            loc = gsc_next_forwards(&it);
        }
 
        if (anyFound) {
            d->n_groups--;
        }
        gsc_delete_bidirectional_iter(&it);
        return outGroup;
 
    } else {
        GSC_CREATE_BUFFER(isDuplicate,_Bool,remaininglistlen);
        memset(isDuplicate, 0, sizeof(_Bool)*remaininglistlen);
        for (size_t ii = i; ii < list_len; ++ii) {
            for (size_t jj = ii+1; jj < list_len; ++jj) {
                if (grouplist[ii].num == grouplist[jj].num) {
                    isDuplicate[jj-i] = 1;
                }
            }
        }
 
        GSC_CREATE_BUFFER(anyFound,_Bool,remaininglistlen);
        memset(anyFound, 0, sizeof(_Bool)*remaininglistlen);
 
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d,GSC_NO_GROUP);
        gsc_GroupNum cachedgroup = GSC_NO_GROUP; // just for speedier lookups. Groups tend to be stored contiguous in most simulations.
        gsc_GenoLocation loc = gsc_next_forwards(&it);
 
        while (GSC_IS_VALID_LOCATION(loc)) {
            if (gsc_get_group(loc).num == cachedgroup.num) {
                gsc_set_group(loc,outGroup);
            } else {
                for (size_t k = i+1; k < list_len; ++k) {
                    if (gsc_get_group(loc).num == grouplist[k].num) {
                        gsc_set_group(loc,outGroup);
                        cachedgroup = grouplist[k];
                        anyFound[k-i] = 1;
                        break;
                    }
                }
            }
 
            loc = gsc_next_forwards(&it);
        }
 
        size_t groupsgone = 0;
        for (size_t j = 0; j < remaininglistlen; ++j) {
            if (!isDuplicate[j] && anyFound[j]) {
                groupsgone++;
            }
        }
        d->n_groups -= groupsgone;
        gsc_delete_bidirectional_iter(&it);
        GSC_DELETE_BUFFER(anyFound);
        GSC_DELETE_BUFFER(isDuplicate);
        return outGroup;
    }
}
 
gsc_GroupNum gsc_make_group_from(gsc_SimData* d, 
                                 const size_t index_list_len, 
                                 const GSC_GLOBALX_T* genotype_indexes) {
    if (index_list_len < 1) {
        fprintf(stderr,"Invalid index_list_len value: length of allocation list must be at least 1\n");
        return GSC_NO_GROUP;
    }
    
    gsc_GroupNum newGroup = gsc_get_new_group_num(d);
    gsc_RandomAccessIterator it = gsc_create_randomaccess_iter(d, GSC_NO_GROUP);
    size_t invalidLocations = 0;
    for (size_t i = 0; i < index_list_len; ++i) {
        gsc_GenoLocation loc = gsc_next_get_nth(&it, genotype_indexes[i]);
        if (GSC_IS_VALID_LOCATION(loc)) {
            gsc_set_group(loc,newGroup);
        } else {
            invalidLocations++;
        }
    }
 
    if (invalidLocations > 0) {
        fprintf(stderr,"%lu indexes were invalid\n",(long unsigned int)invalidLocations);
    }
    gsc_delete_randomaccess_iter(&it);
    
    if (invalidLocations < index_list_len) {
        d->n_groups++;
        return newGroup;
    } else {
        return GSC_NO_GROUP;
    }
}
 
gsc_GroupNum gsc_split_by_label_value(gsc_SimData* d, 
                                      const gsc_GroupNum group, 
                                      const gsc_LabelID whichLabel, 
                                      const int valueToSplit) {
    GSC_ID_T labelix;
    if (whichLabel.id == GSC_NO_LABEL.id || (labelix = gsc_get_index_of_label(d, whichLabel)) == GSC_NA_IDX) {
        fprintf(stderr, "Nonexistent label %lu\n", (long unsigned int)whichLabel.id);
        return GSC_NO_GROUP;
    }
    
    gsc_GroupNum newGroup = gsc_get_new_group_num(d);
    _Bool anyFound = 0;
    
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d, group);
    gsc_GenoLocation loc = gsc_next_forwards(&it);
    while (GSC_IS_VALID_LOCATION(loc)) {
        if (gsc_get_label_value(loc,labelix) == valueToSplit) {
            gsc_set_group(loc,newGroup);
            anyFound = 1;
        }
        
        loc = gsc_next_forwards(&it);
    }
    
    if (anyFound) {
        d->n_groups++;
        return newGroup;
    } else {
        return GSC_NO_GROUP;
    }
 
}
 
gsc_GroupNum gsc_split_by_label_range(gsc_SimData* d, 
                                      const gsc_GroupNum group, 
                                      const gsc_LabelID whichLabel, 
                                      const int valueLowBound, 
                                      const int valueHighBound) {
    GSC_ID_T labelix;
    if (whichLabel.id == GSC_NO_LABEL.id || (labelix = gsc_get_index_of_label(d, whichLabel)) == GSC_NA_IDX) {
        fprintf(stderr, "Nonexistent label %lu\n", (long unsigned int)whichLabel.id);
        return GSC_NO_GROUP;
    }
    if (valueLowBound > valueHighBound) {
        fprintf(stderr, "Empty range %d to %d: no group created\n", valueLowBound, valueHighBound);
        return GSC_NO_GROUP;
    }
 
    gsc_GroupNum newGroup = gsc_get_new_group_num(d);
    _Bool anyFound = 0; 
    
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d, group);
    gsc_GenoLocation loc = gsc_next_forwards(&it);
    while (GSC_IS_VALID_LOCATION(loc)) {
        if (gsc_get_label_value(loc,labelix) >= valueLowBound &&
                gsc_get_label_value(loc,labelix) <= valueHighBound) {
            gsc_set_group(loc,newGroup);
            anyFound = 1;
        }
        
        loc = gsc_next_forwards(&it);
    }
 
    if (anyFound) {
        d->n_groups++;
        return newGroup;
    } else {
        return GSC_NO_GROUP; // no values with that label
    }
}
 
 
size_t gsc_scaffold_split_by_somequality(gsc_SimData* d, 
                                         const gsc_GroupNum group_id,  
                                         void* somequality_data,
                                         gsc_GroupNum (*somequality_tester)(gsc_GenoLocation, 
                                                                            void*, 
                                                                            size_t, 
                                                                            size_t, 
                                                                            gsc_GroupNum*),
                                         size_t maxentries_results, 
                                         gsc_GroupNum* results) {
    // Access existing groups (to be used to find unused group numbers,
    // and to find maximum number of groups we'd be able to create)
    GSC_CREATE_BUFFER(currentgroups,gsc_GroupNum,d->n_groups);
    GSC_CREATE_BUFFER(currentsizes,GSC_GLOBALX_T,d->n_groups);
    size_t n_groups = gsc_get_existing_group_counts(d, currentgroups, currentsizes);
    size_t bookmark = 0;
    gsc_GroupNum nextgroup = GSC_NO_GROUP;
 
    // splitgroupsize is size_t not GLOBALX_T because it will be used as the maximum number of output
    // groups that could be produced, not used to operate on candidates in the group. (By default though
    // GSC_GLOBALX_T is an alias of size_t so it makes no difference).
    size_t splitgroupsize = 0;
    for (size_t i = 0; i < n_groups; ++i) {
        if (currentgroups[i].num == group_id.num) {
            splitgroupsize = currentsizes[i];
            //GSC_FREE(currentsizes);
            break;
        }
    }
    if (splitgroupsize == 0) {
        return 0;
    }
    
    GSC_DELETE_BUFFER(currentsizes);
    size_t subgroupsfound = 0;
    GSC_CREATE_BUFFER(outgroups,gsc_GroupNum,splitgroupsize);
    
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d,group_id);
    gsc_GenoLocation loc = gsc_next_forwards(&it);
    while (GSC_IS_VALID_LOCATION(loc)) {
        // Return group number if it should be assigned to an already-extant group. Otherwise return GSC_NO_GROUP and this generic caller function will allocated it one.
        gsc_GroupNum assignedgroup = somequality_tester(loc, somequality_data, 
                                                        splitgroupsize, subgroupsfound, outgroups);
        
        if (assignedgroup.num == GSC_NO_GROUP.num) {
            nextgroup = gsc_get_next_free_group_num(n_groups,currentgroups,&bookmark,nextgroup);
            assignedgroup = nextgroup;
            outgroups[subgroupsfound] = nextgroup;
            subgroupsfound++;   
        }
        
        gsc_set_group(loc,assignedgroup);
        
        loc = gsc_next_forwards(&it);
    }
    
    GSC_DELETE_BUFFER(currentgroups);
    d->n_groups += subgroupsfound - 1;
    
    if (maxentries_results < subgroupsfound) { 
        memcpy(results,outgroups,sizeof(gsc_GroupNum)*maxentries_results);
        fprintf(stderr,"Output vector size is not large enough to hold all created groups: "
                " output list of gsc_GroupNums has been truncated\n");
    } else {
        memcpy(results,outgroups,sizeof(gsc_GroupNum)*subgroupsfound);
    }
    GSC_DELETE_BUFFER(outgroups);
    return subgroupsfound;
}
 
static gsc_GroupNum gsc_helper_split_by_quality_halfsibtemplate(gsc_GenoLocation loc, 
                                                                void* datastore, 
                                                                size_t maxgroups, 
                                                                size_t groupsfound, 
                                                                gsc_GroupNum* results, 
                                                                gsc_PedigreeID (*getparent)(gsc_GenoLocation)) {
    gsc_PedigreeID* familyidentities = (gsc_PedigreeID*) datastore;
    
    for (size_t j = 0; j < groupsfound; ++j) {
        if (getparent(loc).id == familyidentities[j].id) {
            return results[j];
        }
    }
    
    if (groupsfound > maxgroups) {
        fprintf(stderr, "Attempted to split into more groups than caller deemed possible. "
            "There is a bug in the simulation tool if you can reach this state.");
        return results[maxgroups-1]; // allocate all to the last group, possibly incorrectly.
    }
    
    familyidentities[groupsfound] = getparent(loc);
    return GSC_NO_GROUP;
}
 
static gsc_GroupNum gsc_helper_split_by_quality_halfsib1(gsc_GenoLocation loc, 
                                                         void* datastore, 
                                                         size_t maxgroups, 
                                                         size_t groupsfound, 
                                                         gsc_GroupNum* results) {
    return gsc_helper_split_by_quality_halfsibtemplate(loc,datastore,maxgroups,groupsfound,results,
                                                       gsc_get_first_parent);
}
 
static gsc_GroupNum gsc_helper_split_by_quality_halfsib2(gsc_GenoLocation loc, 
                                                         void* datastore, 
                                                         size_t maxgroups, 
                                                         size_t groupsfound, 
                                                         gsc_GroupNum* results) {
    return gsc_helper_split_by_quality_halfsibtemplate(loc,datastore,maxgroups,groupsfound,results,
                                                       gsc_get_second_parent);
}
 
size_t gsc_split_into_halfsib_families(gsc_SimData* d, 
                                       const gsc_GroupNum group_id, 
                                       const int parent, 
                                       size_t maxentries_results, 
                                       gsc_GroupNum* results) {
    if (!(parent == 1 || parent == 2)) {
        fprintf(stderr, "Value error: `parent` must be 1 or 2.");
        results = NULL;
        return 0;
    }
    
    //gsc_PedigreeID* familyidentities = gsc_malloc_wrap(sizeof(gsc_PedigreeID)*maxgroups);
    GSC_GLOBALX_T maxgroups = gsc_get_group_size(d, group_id); // sadinefficient we have to do this
    GSC_CREATE_BUFFER(familyidentities,gsc_PedigreeID,maxgroups);
    
    size_t gcount;
    if (parent == 1) {
        gcount = gsc_scaffold_split_by_somequality(d, group_id, (void*)familyidentities,
                                                   gsc_helper_split_by_quality_halfsib1, 
                                                   maxentries_results, results);
    } else {
        gcount = gsc_scaffold_split_by_somequality(d, group_id, (void*)familyidentities, 
                                                   gsc_helper_split_by_quality_halfsib2, 
                                                   maxentries_results, results);
    }   
 
    GSC_DELETE_BUFFER(familyidentities);
    return gcount;
}
 
static gsc_GroupNum gsc_helper_split_by_quality_family(gsc_GenoLocation loc, 
                                                       void* datastore, 
                                                       size_t maxgroups, 
                                                       size_t groupsfound, 
                                                       gsc_GroupNum* results) {
    gsc_PedigreeID** familyidentities = (gsc_PedigreeID**) datastore;
    
    for (size_t j = 0; j < groupsfound; ++j) {
        if (gsc_get_first_parent(loc).id == familyidentities[0][j].id &&
              gsc_get_second_parent(loc).id == familyidentities[1][j].id) {
            return results[j];
        }
    }
    
    if (groupsfound > maxgroups) {
        fprintf(stderr, "Attempted to split into more groups than caller deemed possible. "
            "There is a bug in the simulation tool if you can reach this state.");
        return results[maxgroups-1]; // allocate all to the last group, possibly incorrectly.
    }
    
    familyidentities[0][groupsfound] = gsc_get_first_parent(loc);
    familyidentities[1][groupsfound] = gsc_get_second_parent(loc);
    return GSC_NO_GROUP;
}
 
size_t gsc_split_into_families(gsc_SimData* d, 
                               const gsc_GroupNum group_id, 
                               size_t maxentries_results, 
                               gsc_GroupNum* results) {
    gsc_PedigreeID* familyidentities[2];
    GSC_GLOBALX_T maxgroups = gsc_get_group_size(d, group_id); // sadinefficient we have to do this
    if (maxgroups < 2) {
        return 0;
    }
 
    GSC_CREATE_BUFFER(p1identity,gsc_PedigreeID,maxgroups);
    GSC_CREATE_BUFFER(p2identity,gsc_PedigreeID,maxgroups);
    familyidentities[0] = p1identity;
    familyidentities[1] = p2identity;
    
    size_t out = gsc_scaffold_split_by_somequality(d, group_id, (void*)familyidentities, 
                                                   gsc_helper_split_by_quality_family, 
                                                   maxentries_results, results);
 
    GSC_DELETE_BUFFER(p1identity);
    GSC_DELETE_BUFFER(p2identity);
 
    return out;
}
 
static gsc_GroupNum gsc_helper_split_by_quality_individuate(gsc_GenoLocation loc, 
                                                            void* datastore, 
                                                            size_t maxgroups, 
                                                            size_t groupsfound, 
                                                            gsc_GroupNum* results) {
    return GSC_NO_GROUP;
}
 
size_t gsc_split_into_individuals(gsc_SimData* d, 
                                  const gsc_GroupNum group_id, 
                                  size_t maxentries_results, 
                                  gsc_GroupNum* results) {
    // **individuate** (verb): to make individuals of.
    // yeah sorry.
    return gsc_scaffold_split_by_somequality(d, group_id, NULL, 
                                             gsc_helper_split_by_quality_individuate, 
                                             maxentries_results, results);
}
 
 
gsc_GroupNum gsc_split_evenly_into_two(gsc_SimData* d, 
                                       const gsc_GroupNum group_id) {
    // get the shuffle to be our even allocations
    GSC_GLOBALX_T size = gsc_get_group_size(d, group_id);
    if (size < 2) {
        if (size < 1) {
            fprintf(stderr,"Group %lu does not exist\n", (long unsigned int) group_id.num);
        } else {
            fprintf(stderr,"Group %lu has only one member so can't be split\n", (long unsigned int) group_id.num);
        }
        return GSC_NO_GROUP;
    }
 
    GSC_GLOBALX_T even_half = size / 2;
    GSC_CREATE_BUFFER(allocations,GSC_GLOBALX_T,size);
    for (GSC_GLOBALX_T i = 0; i < size; ++i) {
        allocations[i] = i;
    }
    gsc_shuffle_up_to(&d->rng, allocations, sizeof(allocations[0]), size, even_half);
 
    gsc_GroupNum new_group = gsc_get_new_group_num(d);
    
    gsc_RandomAccessIterator it = gsc_create_randomaccess_iter(d,group_id);
    for (GSC_GLOBALX_T i = 0; i < even_half; ++i) {
        gsc_GenoLocation loc = gsc_next_get_nth(&it,allocations[i]);
        if (GSC_IS_VALID_LOCATION(loc)) {
            gsc_set_group(loc,new_group);
        }
    }
 
    GSC_DELETE_BUFFER(allocations);
    gsc_delete_randomaccess_iter(&it);
 
    d->n_groups++;
    return new_group;
}
 
 
size_t gsc_scaffold_split_by_someallocation(gsc_SimData* d, 
                                            const gsc_GroupNum group_id, 
                                            void* someallocator_data,
                                            gsc_GroupNum (*someallocator)(gsc_GenoLocation, 
                                                                          gsc_SimData*, 
                                                                          void*, 
                                                                          size_t, 
                                                                          size_t*, 
                                                                          gsc_GroupNum*),
                                            size_t n_outgroups, 
                                            gsc_GroupNum* outgroups) {
 
    // get the n group numbers
    gsc_get_n_new_group_nums(d, n_outgroups, outgroups);
 
    size_t subgroupsfound = 0;
    GSC_GLOBALX_T allocationfailures = 0;
 
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d,group_id);
    gsc_GenoLocation loc = gsc_next_forwards(&it);
    while (GSC_IS_VALID_LOCATION(loc)) {
        gsc_GroupNum assignedgroup = someallocator(loc, d, someallocator_data, 
                                                   n_outgroups, &subgroupsfound, outgroups);
        if (assignedgroup.num != GSC_NO_GROUP.num) {
            gsc_set_group(loc,assignedgroup);
        } else {
            allocationfailures++;
        }
 
        loc = gsc_next_forwards(&it);
    }
 
    if (subgroupsfound > 1) {
        d->n_groups += subgroupsfound - 1;
    }
    if (allocationfailures > 0) {
        fprintf(stderr,"While splitting group %lu, %lu allocations to new groups failed so they remain"
                       " in the original group\n",
                (long unsigned int) group_id.num, (long unsigned int) allocationfailures);
    }
    return subgroupsfound;
 
}
 
 
static gsc_GroupNum gsc_helper_split_by_allocator_knowncounts(gsc_GenoLocation loc,
                                                              gsc_SimData* d, 
                                                              void* datastore, 
                                                              size_t n_outgroups,
                                                              size_t* subgroupsfound, 
                                                              gsc_GroupNum* outgroups) {
    GSC_GLOBALX_T* cumulative_counts = (GSC_GLOBALX_T*) datastore;
    *subgroupsfound = n_outgroups;
    // type note: may misbehave with large numbers because is just designed for ints
    int randpos = rnd_pcg_range(&d->rng,0,cumulative_counts[n_outgroups-1] - 1); 
    
    gsc_GroupNum chosengroup = GSC_NO_GROUP;
    size_t j = 0;
    for (; j < n_outgroups; ++j) {
        if (randpos < cumulative_counts[j]) {
            chosengroup = outgroups[j];
            break;
        }
    }
    for (; j < n_outgroups; ++j) {
        cumulative_counts[j]--;
    }
    return chosengroup;
}
 
size_t gsc_split_evenly_into_n(gsc_SimData* d, 
                               const gsc_GroupNum group_id, 
                               const size_t n, 
                               gsc_GroupNum* results) {
    if (n <= 1) {
        fprintf(stderr, "Invalid n value: number of fractions into which to split group must be at least 2\n");
        return 0;
    }
 
    GSC_GLOBALX_T size = gsc_get_group_size(d, group_id); // sadinefficient we have to do this.
 
    // get the shuffle to be our even allocations
    GSC_GLOBALX_T each_size = size / n;
    GSC_GLOBALX_T extra = size % n;
    GSC_CREATE_BUFFER(boxes,GSC_GLOBALX_T,n);
    for (size_t i = 0; i < n; ++i) {
        boxes[i] = each_size;
        if (i < extra) {
            boxes[i]++;
        }
        if (i > 0) {
            boxes[i] += boxes[i-1];
        }
    }
    
    size_t out;
    if (results == NULL) {
        GSC_CREATE_BUFFER(outgroups,gsc_GroupNum, n);
        out = gsc_scaffold_split_by_someallocation(d, group_id, (void*) boxes, 
                                                   gsc_helper_split_by_allocator_knowncounts, 
                                                   n, outgroups);
        GSC_DELETE_BUFFER(outgroups);
    } else {
        out = gsc_scaffold_split_by_someallocation(d, group_id, (void*) boxes, 
                                                   gsc_helper_split_by_allocator_knowncounts, 
                                                   n, results);
    }
    GSC_DELETE_BUFFER(boxes);
    return out;
}
 
size_t gsc_split_into_buckets(gsc_SimData* d, 
                              const gsc_GroupNum group_id, 
                              const size_t n, 
                              const GSC_GLOBALX_T* counts, 
                              gsc_GroupNum* results) {
    if (n <= 1) {
        fprintf(stderr, "Invalid n value: number of fractions into which to split group must be at least 2\n");
        return 0;
    }
 
    GSC_CREATE_BUFFER(cumulative_counts,GSC_GLOBALX_T,n);
    cumulative_counts[n-1] = gsc_get_group_size(d, group_id);
    GSC_GLOBALX_T sum = 0;
    for (size_t j = 0; j < n - 1; ++j) {
        sum += counts[j];
        cumulative_counts[j] = sum;
    }
    if (cumulative_counts[n-2] > cumulative_counts[n-1]) {
        fprintf(stderr, "Provided capacities are larger than actual group: some buckets will not be filled\n");
    }
 
    size_t gcount;
    if (results == NULL) {
        GSC_CREATE_BUFFER(outgroups,gsc_GroupNum,n);
        gcount = gsc_scaffold_split_by_someallocation(d, group_id, (void*) cumulative_counts, 
                                                      gsc_helper_split_by_allocator_knowncounts, 
                                                      n, outgroups);
        GSC_DELETE_BUFFER(outgroups);
    } else {
        gcount = gsc_scaffold_split_by_someallocation(d, group_id, (void*) cumulative_counts, 
                                                      gsc_helper_split_by_allocator_knowncounts, 
                                                      n, results);
    }
 
    GSC_DELETE_BUFFER(cumulative_counts);
    return gcount;
}
 
gsc_GroupNum gsc_split_randomly_into_two(gsc_SimData* d, 
                                         const gsc_GroupNum group_id) {
    gsc_GroupNum outGroup = gsc_get_new_group_num(d);
    _Bool anyFound = 0;
    
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d, group_id);
    gsc_GenoLocation loc = gsc_next_forwards(&it);
    while (GSC_IS_VALID_LOCATION(loc)) {
        anyFound = 1;
        if (rnd_pcg_range(&d->rng,0,1)) {
            gsc_set_group(loc,outGroup);
        }
        loc = gsc_next_forwards(&it);
    }
    gsc_delete_bidirectional_iter(&it);
 
    if (anyFound) {
        d->n_groups++;
        return outGroup;
    } else {
        return GSC_NO_GROUP;
    }
}
 
 
static gsc_GroupNum gsc_helper_split_by_allocator_equalprob(gsc_GenoLocation loc, 
                                                            gsc_SimData* d, 
                                                            void* datastore, 
                                                            size_t n_outgroups,
                                                            size_t* subgroupsfound, 
                                                            gsc_GroupNum* outgroups) {
    // consideration: will be an issue in C version if n_outgroups > INT_MAX.
    size_t randgroup = rnd_pcg_range(&d->rng,0,n_outgroups-1);
    if (randgroup < *subgroupsfound) {
        return outgroups[randgroup];
    } else {
        (*subgroupsfound)++;
        return outgroups[*subgroupsfound-1];
    }
}
 
size_t gsc_split_randomly_into_n(gsc_SimData* d, 
                                 const gsc_GroupNum group_id, 
                                 const size_t n, 
                                 gsc_GroupNum* results) {
    if (n <= 1) {
        fprintf(stderr, "Invalid n value: number of fractions in which to split group must be at least 2\n");
        return 0;
    }
 
    size_t gcount;
    if (results == NULL) {
        GSC_CREATE_BUFFER(outgroups,gsc_GroupNum,n);
        gcount = gsc_scaffold_split_by_someallocation(d, group_id, NULL, 
                                                      gsc_helper_split_by_allocator_equalprob, 
                                                      n, outgroups);
        GSC_DELETE_BUFFER(outgroups);
    } else {
        gcount = gsc_scaffold_split_by_someallocation(d, group_id, NULL, 
                                                      gsc_helper_split_by_allocator_equalprob, 
                                                      n, results);
    }
    return gcount;
}
 
 
static gsc_GroupNum gsc_helper_split_by_allocator_unequalprob(gsc_GenoLocation loc, 
                                                              gsc_SimData* d, 
                                                              void* datastore, 
                                                              size_t n_outgroups,
                                                              size_t* subgroupsfound, 
                                                              gsc_GroupNum* outgroups) {
    double* cumulative_probs = (double*) datastore;
    *subgroupsfound = n_outgroups;
    double randdraw = rnd_pcg_nextf(&d->rng);
    for (size_t j = 0; j < n_outgroups; ++j) {
        if (randdraw < cumulative_probs[j]) {
            return outgroups[j];
        }
    }
    // This should not happen if cumulative probs are valid
    return GSC_NO_GROUP;
}
 
size_t gsc_split_by_probabilities(gsc_SimData* d, 
                                  const gsc_GroupNum group_id, 
                                  const size_t n, 
                                  const double* probs, 
                                  gsc_GroupNum* results) {
    if (n <= 1) {
        fprintf(stderr, "Invalid n value: number of fractions in which to split group must be at least 2\n");
        return 0;
    }
 
    // Check the probabilities
    GSC_CREATE_BUFFER(cumulative_probs,double,n);
    cumulative_probs[n-1] = 1.0;
    double sum = 0;
    for (size_t j = 0; j < n-1; ++j) {
        sum += probs[j];
        cumulative_probs[j] = sum;
        if (cumulative_probs[j] >= 1) {
            fprintf(stderr, "Provided probabilities add up to 1 or more: some buckets will not be filled\n");
            for (; j < n-1; ++j) {
                cumulative_probs[j] = 1;
            }
          //don't bother to calculate more
          break;
        }
    }
    
    size_t gcount;
    if (results == NULL) {
        GSC_CREATE_BUFFER(outgroups,gsc_GroupNum,n);
        gcount = gsc_scaffold_split_by_someallocation(d, group_id, (void*) cumulative_probs, 
                                                      gsc_helper_split_by_allocator_unequalprob, 
                                                      n, outgroups);
        GSC_DELETE_BUFFER(outgroups);
    } else {
        gcount = gsc_scaffold_split_by_someallocation(d, group_id, (void*) cumulative_probs, 
                                                      gsc_helper_split_by_allocator_unequalprob, 
                                                      n, results);
    }
 
    GSC_DELETE_BUFFER(cumulative_probs);
    return gcount;
}
 
 
size_t gsc_get_existing_groups(gsc_SimData* d, gsc_GroupNum* output) {
    return gsc_get_existing_group_counts(d, output, NULL);
}
 
size_t gsc_get_existing_group_counts( gsc_SimData* d, gsc_GroupNum* out_groups, GSC_GLOBALX_T* out_sizes) {
    GSC_CREATE_BUFFER(buckets,GSC_GLOBALX_T,d->n_groups+1); // this also creates bucketscap, initalised to d->n_groups+1.
    memset(buckets,0,sizeof(GSC_GLOBALX_T)*bucketscap);
    size_t filledbuckets = 0;
 
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter(d, GSC_NO_GROUP);
    gsc_GenoLocation loc = gsc_next_forwards(&it);
    while (GSC_IS_VALID_LOCATION(loc)) {
        gsc_GroupNum g = gsc_get_group(loc);
        // Unless all group numbers are consecutive starting at 1, the buckets array will need to be resized at some point.
        if (g.num >= bucketscap) {
            size_t oldcap = bucketscap;
            size_t newbucketcapacity = bucketscap;
            while (g.num >= newbucketcapacity) {
                newbucketcapacity *= 2;
            }
            GSC_STRETCH_BUFFER(buckets,newbucketcapacity);
            if (g.num >= bucketscap) {
                fprintf(stderr,"Memory allocation failed. Not all groups found\n");
                break;
            }
            memset(buckets+oldcap,0,sizeof(GSC_GLOBALX_T)*(bucketscap-oldcap));
 
        }
 
        buckets[g.num] += 1;
        if (buckets[g.num] == 1) {
            ++filledbuckets;
        }
 
        loc = gsc_next_forwards(&it);
    }
 
    // Now save to output and sort.
    size_t capacity = filledbuckets;
    if (capacity > d->n_groups) {
        fprintf(stderr,"Found more groups than expected - gsc_SimData.n_groups is outdated somewhere."
                " Trimming output of get_existing_group_ to avoid a crash: not all groups may be shown\n");
        capacity = d->n_groups;
    }
    size_t g_index = 0;
    for (size_t i = 1; i < bucketscap; ++i) {
        if (buckets[i]) {
            /*if (g_index >= capacity) {
                fprintf(stderr,"Found more groups than just a moment ago.");
                --g_index;
                break;
            }*/
 
            if (out_groups != NULL) {
                out_groups[g_index] = (gsc_GroupNum){.num=i};
            }
            if (out_sizes != NULL) {
                out_sizes[g_index] = buckets[i];
            }
            ++g_index;
        }
    }
 
    //qsort(*out_groups, g_index, sizeof(gsc_GroupNum), gsc_helper_ascending_gsc_GroupNum_comparer);
    /*for (int i = 0; i < g_index; ++i) {
        (*out_sizes)[i] = buckets[(*out_groups)[i].num];
    }*/
    GSC_DELETE_BUFFER(buckets);
    d->n_groups = g_index;
 
    return g_index;
}
 
 
gsc_GroupNum gsc_get_next_free_group_num(const size_t n_existing_groups, 
                                         const gsc_GroupNum* existing_groups, 
                                         size_t* cursor,
                                         gsc_GroupNum previous) {
    if (existing_groups == NULL) return GSC_NO_GROUP;
 
    gsc_GroupNum nextgroup = (gsc_GroupNum){.num=previous.num+1};
    // a check here in case previous seems invalid. We need previous so we don't get stuck in a loop
    // of giving the same next 'free' number, but we know what a lower bound on its number should be
    // based on where the cursor is.
    if (*cursor > 0 && nextgroup.num <= existing_groups[(*cursor) - 1].num) {
        nextgroup.num = existing_groups[(*cursor) - 1].num + 1;
    }
 
    while (*cursor < n_existing_groups) {
        if (nextgroup.num < existing_groups[*cursor].num) {
            break;
        }
 
        ++(*cursor);
        ++nextgroup.num;
    }
    return nextgroup;
}
 
gsc_GroupNum gsc_get_new_group_num(gsc_SimData* d) {
    // Make sure we get all existing groups
    if (d->m == NULL || (d->m->n_genotypes == 0 && d->m->next == NULL)) {
        return (gsc_GroupNum){.num=1};
    }
 
    size_t n_groups = (d->n_groups > 0) ? d->n_groups : 5;
    GSC_CREATE_BUFFER(existing_groups,gsc_GroupNum,n_groups);
    n_groups = gsc_get_existing_groups(d, existing_groups);
 
    size_t i = 0;
    GSC_ID_T gn = 1;
 
    while (i < n_groups) {
        if (gn < existing_groups[i].num) {
            break;
        }
 
        ++i;
        ++gn;
    }
    GSC_DELETE_BUFFER(existing_groups);
    return (gsc_GroupNum){.num=gn};
}
 
 
void gsc_get_n_new_group_nums(gsc_SimData* d, 
                              const size_t n, 
                              gsc_GroupNum* result) {
    // Make sure we get all existing groups
    size_t n_groups;
    GSC_CREATE_BUFFER(existing_groups,gsc_GroupNum,d->n_groups);
    n_groups = gsc_get_existing_groups(d, existing_groups);
 
    size_t existingi = 0;
    GSC_ID_T gn = 0;
 
    // i: current index of `results` (the array of currently empty group numbers)
    // gn: group number being checked against existing_groups. if not in there is added to
    //     the list of results
    // existingi: current index of existing_groups
    for (size_t i = 0; i < n; ++i) {
        ++gn;
        while (existingi < n_groups) {
            if (gn < existing_groups[existingi].num) {
                break;
            }
 
            ++existingi;
            ++gn;
        }
        result[i] = (gsc_GroupNum){.num=gn};
    }
    GSC_DELETE_BUFFER(existing_groups);
}
 
gsc_LabelID gsc_get_new_label_id( const gsc_SimData* d ) {
    // label_ids must be in sequential order
    gsc_LabelID new = {.id=1};
    GSC_ID_T i = 0;
 
    while (i < d->n_labels) {
        if (new.id < d->label_ids[i].id) {
            break;
        }
 
        ++i;
        ++(new.id);
    }
 
    return new;
}
 
gsc_EffectID gsc_get_new_eff_set_id( const gsc_SimData* d ) {
    // label_ids must be in sequential order
    gsc_EffectID new = { .id=1 };
    GSC_ID_T i = 0;
 
    while (i < d->n_eff_sets) {
        if (new.id < d->eff_set_ids[i].id) {
            break;
        }
 
        ++i;
        ++(new.id);
    }
 
    return new;
}
 
gsc_MapID gsc_get_new_map_id( const gsc_SimData* d) {
    // map IDs must be in sequential order
    gsc_MapID new = { .id=1 };
    GSC_ID_T i = 0;
 
    while (i < d->genome.n_maps) {
        if (new.id < d->genome.map_ids[i].id) {
            break;
        }
 
        ++i;
        ++(new.id);
    }
 
    return new;
}
 
 
GSC_ID_T gsc_get_index_of_label( const gsc_SimData* d, const gsc_LabelID label ) {
    if (d->n_labels == 0) { return GSC_NA_IDX; } // immediate fail
    if (d->n_labels == 1) { return (d->label_ids[0].id == label.id) ? 0 : GSC_NA_IDX ; }
    if (label.id == GSC_NO_LABEL.id) { return GSC_NA_IDX; }
 
    // If there's at least two labels then we binary search.
    GSC_ID_T first = 0;
    GSC_ID_T last = d->n_labels;
    GSC_ID_T mid;
 
    while (first <= last) {
        mid = (first + last) / 2;
 
        if (d->label_ids[mid].id == label.id) {
            return mid;
        } else if (d->label_ids[mid].id < label.id) {
            first = mid + 1;
        } else {
            last = mid - 1;
        }
 
    }
 
    return GSC_NA_IDX;
}
 
GSC_ID_T gsc_get_index_of_eff_set( const gsc_SimData* d, const gsc_EffectID eff_set_id ) {
    if (d->n_eff_sets == 0) { return GSC_NA_IDX; } // immediate fail
    if (d->n_eff_sets == 1) { return (d->eff_set_ids[0].id == eff_set_id.id) ? 0 : GSC_NA_IDX ; }
    if (eff_set_id.id == GSC_NO_EFFECTSET.id) { return GSC_NA_IDX; }
 
    // If there's at least two labels then we binary search.
    GSC_ID_T first = 0;
    GSC_ID_T last = d->n_eff_sets;
    GSC_ID_T mid;
 
    while (first <= last) {
        mid = (first + last) / 2;
 
        if (d->eff_set_ids[mid].id == eff_set_id.id) {
            return mid;
        } else if (d->eff_set_ids[mid].id < eff_set_id.id) {
            first = mid + 1;
        } else {
            last = mid - 1;
        }
 
    }
 
    return GSC_NA_IDX;
}
 
GSC_ID_T gsc_get_index_of_map( const SimData* d, const gsc_MapID map ) {
    if (d->genome.n_maps == 0) { return GSC_NA_IDX; } // immediate fail
    if (d->genome.n_maps == 1) { return (d->genome.map_ids[0].id == map.id) ? 0 : GSC_NA_IDX ; }
    if (map.id == GSC_NO_MAP.id) { return GSC_NA_IDX; }
 
    // If there's at least two labels then we binary search.
    GSC_ID_T first = 0;
    GSC_ID_T last = d->genome.n_maps;
    GSC_ID_T mid;
 
    while (first <= last) {
        mid = (first + last) / 2;
 
        if (d->genome.map_ids[mid].id == map.id) {
            return mid;
        } else if (d->genome.map_ids[mid].id < map.id) {
            first = mid + 1;
        } else {
            last = mid - 1;
        }
 
    }
 
    return GSC_NA_IDX;
}
 
//-----------------------------------Data Access-----------------------------------
 
GSC_GLOBALX_T gsc_get_group_size( const gsc_SimData* d, const gsc_GroupNum group_id) {
    if (group_id.num == GSC_NO_GROUP.num) {
        return 0; // it is not a group so it does not have a size
    }
    const gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T size = 0;
    while (m != NULL) {
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
            if (m->groups[i].num == group_id.num) {
                ++size;
            }
        }
 
        m = m->next;
    }
    return size;
}
 
GSC_GLOBALX_T gsc_get_group_genes(const gsc_SimData* d, 
                                  const gsc_GroupNum group_id, 
                                  GSC_GLOBALX_T group_size, 
                                  char** output) {
    const gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T outix = 0;
    while (m != NULL) {
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
            if (m->groups[i].num == group_id.num) {
                output[outix] = m->alleles[i];
                ++outix;
                if (outix == group_size) {
                    return outix;
                }
            }
        }
 
        m = m->next;
    }
    return outix;
}
 
GSC_GLOBALX_T gsc_get_group_names(const gsc_SimData* d, 
                                  const gsc_GroupNum group_id, 
                                  GSC_GLOBALX_T group_size, 
                                  char** output) {
    const gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T outix = 0;
    while (m != NULL) {
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
            if (m->groups[i].num == group_id.num) {
                output[outix] = m->names[i];
                ++outix;
                if (outix == group_size) {
                    return outix;
                }
            }
        }
 
        m = m->next;
    }
    return outix;
}
 
GSC_GLOBALX_T gsc_get_group_ids(const gsc_SimData* d, 
                                const gsc_GroupNum group_id, 
                                GSC_GLOBALX_T group_size, 
                                gsc_PedigreeID *output) {
    const gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T outix = 0;
    while (m != NULL) {
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
            if (m->groups[i].num == group_id.num) {
                output[outix] = m->ids[i];
                ++outix;
                if (outix == group_size) {
                    return outix;
                }
            }
        }
 
        m = m->next;
    }
    return outix;
}
 
GSC_GLOBALX_T gsc_get_group_indexes(const gsc_SimData* d, 
                                    const gsc_GroupNum group_id, 
                                    GSC_GLOBALX_T group_size, 
                                    GSC_GLOBALX_T* output) {
    const gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T total_i = 0, outix = 0;
    while (m != NULL) {
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i, ++total_i) {
            if (m->groups[i].num == group_id.num) {
                output[outix] = total_i;
                ++outix;
                if (outix == group_size) {
                    return outix;
                }
            }
        }
 
        m = m->next;
    }
    return outix;
}
 
GSC_GLOBALX_T gsc_get_group_bvs(const gsc_SimData* d, 
                                const gsc_GroupNum group_id, 
                                const gsc_EffectID effID, 
                                GSC_GLOBALX_T group_size, 
                                double* output) {
    gsc_DecimalMatrix dm_bvs = gsc_calculate_bvs(d, group_id, effID );
 
    if (group_size == 0 || group_size == GSC_NA_GLOBALX) {
        group_size = dm_bvs.dim2;
    }
 
    memcpy(output, dm_bvs.matrix[0], sizeof(*output)*group_size);
 
    gsc_delete_dmatrix(&dm_bvs);
    return group_size;
}
 
GSC_GLOBALX_T gsc_get_group_parent_ids(const gsc_SimData* d, 
                                       const gsc_GroupNum group_id, 
                                       GSC_GLOBALX_T group_size, 
                                       const int whichParent, 
                                       gsc_PedigreeID* output) {
    if (!(whichParent == 1 || whichParent == 2)) {
        fprintf(stderr, "Value error: `parent` must be 1 or 2.");
        return GSC_NA_GLOBALX;
    }
    int parent = whichParent - 1;
 
    const gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T outix = 0;
    while (m != NULL) {
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
            if (m->groups[i].num == group_id.num) {
                output[outix] = m->pedigrees[parent][i];
                ++outix;
                if (outix == group_size) {
                    return outix;
                }
            }
        }
 
        m = m->next;
    }
    return outix;
}
 
GSC_GLOBALX_T gsc_get_group_parent_names(const gsc_SimData* d,
                                         const gsc_GroupNum group_id,
                                         GSC_GLOBALX_T group_size, 
                                         const int whichParent, 
                                         char** output) {
    if (!(whichParent == 1 || whichParent == 2)) {
        fprintf(stderr, "Value error: `parent` must be 1 or 2.");
        return GSC_NA_GLOBALX;
    }
    int parent = whichParent - 1;
 
    const gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T outix = 0;
    while (m != NULL) {
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
            if (m->groups[i].num == group_id.num) {
                if (m->pedigrees[parent][i].id != GSC_NO_PEDIGREE.id) {
                    output[outix] = gsc_get_name_of_id(d->m, m->pedigrees[parent][i]);
                } else {
                    output[outix] = NULL;
                }
                ++outix;
                if (outix == group_size) {
                    return outix;
                }
            }
        }
 
        m = m->next;
    }
    return outix;
}
 
GSC_GLOBALX_T gsc_get_group_pedigrees(const gsc_SimData* d, 
                                      const gsc_GroupNum group_id, 
                                      GSC_GLOBALX_T group_size, 
                                      char** output) {
    char* fname = "gS_gpptmp";
    gsc_save_pedigrees(fname,d,group_id,GSC_TRUE);
 
    FILE* fp2;
    if ((fp2 = fopen(fname, "r")) == NULL) {
        fprintf(stderr, "Failed to use temporary file\n");
        return GSC_NA_GLOBALX;
    }
 
    // Create the list that we will return
    if (group_size == 0 || group_size == GSC_NA_GLOBALX) {
        group_size = gsc_get_group_size( d, group_id );
        if (group_size == 0) { return 0; }
    }
 
    // read one line at a time
    //size_t n;
    //int line_len;
    unsigned int size;
    unsigned int index;
    int nextc;
    for (GSC_GLOBALX_T i = 0; i < group_size; ++i) {
        // getline is not available in MinGW it looks like (AUG 2021)
        /*gp_ped[i] = NULL;
        if ((line_len = getline(&(gp_ped[i]), &n, fp2)) == -1) {
            error("Failed to get %d th pedigree\n", i);
        }
        // remove the newline character
        if (gp_ped[i][line_len - 1] == '\n') {
            gp_ped[i][line_len - 1] = '\0';
        }*/
 
        // a not-very-size-efficient, fgets-based line getter
        size = 50;
        index = 0;
        output[i] = gsc_malloc_wrap(sizeof(char) * size,GSC_TRUE);
        while ((nextc = fgetc(fp2)) != '\n' && nextc != EOF) {
            output[i][index] = nextc;
            ++index;
 
            if (index >= size) {
                size *= 2;
                char* temp = realloc(output[i], sizeof(char) * size);
                if (temp == NULL) {
                    GSC_FREE(output[i]);
                    fprintf(stderr, "Memory allocation of size %u failed.\n", size);
                    output[i] = NULL;
                } else {
                    output[i] = temp;
                }
            }
        }
        output[i][index] = '\0';
    }
 
    fclose(fp2);
    remove(fname);
 
    return group_size;
}
 
/*---------------------- matrix-operations.c dregs -------------------*/
 
gsc_DecimalMatrix gsc_generate_zero_dmatrix(const size_t r, const size_t c) {
    gsc_DecimalMatrix zeros;
    zeros.dim1 = r;
    zeros.dim2 = c;
 
    if (r > 0) {
        zeros.matrix = gsc_malloc_wrap(sizeof(*zeros.matrix) * r,GSC_TRUE);
        if (c > 0) {
            for (size_t i = 0; i < r; ++i) {
                zeros.matrix[i] = gsc_malloc_wrap(sizeof(*(zeros.matrix[i])) * c,GSC_TRUE);
                for (size_t j = 0; j < c; ++j) {
                    zeros.matrix[i][j] = 0.0;
                }
            }
        } else {
            for (size_t i = 0; i < r; ++i) {
                zeros.matrix[i] = NULL;
            }
        }
    } else {
        zeros.matrix = NULL;
    }
    return zeros;
}
 
void gsc_delete_dmatrix(gsc_DecimalMatrix* m) {
    if (m->matrix != NULL) {
        for (size_t i = 0; i < m->dim1; i++) {
            if (m->matrix[i] != NULL) {
                GSC_FREE(m->matrix[i]);
            }
        }
        GSC_FREE(m->matrix);
        m->matrix = NULL;
    }
    m->dim1 = 0;
    m->dim2 = 0;
}
 
 
/*--------------------------------Deleting-----------------------------------*/
 
void gsc_delete_group(gsc_SimData* d, const gsc_GroupNum group_id) {
    gsc_AlleleMatrix* m = d->m;
    GSC_GLOBALX_T total_deleted = 0;
    while (m != NULL) {
        GSC_LOCALX_T deleted = 0;
        for (GSC_LOCALX_T i = 0; i < m->n_genotypes; ++i) {
            if (m->groups[i].num == group_id.num) {
                // delete data
                if (m->names[i] != NULL) {
                    GSC_FREE(m->names[i]);
                    m->names[i] = NULL;
                }
                if (m->alleles[i] != NULL) {
                    GSC_FREE(m->alleles[i]);
                    m->alleles[i] = NULL;
                }
                m->ids[i] = GSC_NO_PEDIGREE;
                m->pedigrees[0][i] = GSC_NO_PEDIGREE;
                m->pedigrees[1][i] = GSC_NO_PEDIGREE;
                m->groups[i] = GSC_NO_GROUP;
                ++deleted;
            }
        }
        m->n_genotypes -= deleted;
        total_deleted += deleted;
 
        m = m->next;
    }
    printf("%lu genotypes were deleted\n", (long unsigned int) total_deleted);
    if (total_deleted > 0) { 
        gsc_condense_allele_matrix( d );
        d->n_groups--; 
    }
}
 
void gsc_delete_eff_set(gsc_SimData* d, gsc_EffectID effID) {
    GSC_ID_T which_ix = gsc_get_index_of_eff_set(d, effID);
    if (which_ix == GSC_NA_LOCALX) {
        fprintf(stderr, "Nonexistent effect set %lu\n", (long unsigned int) effID.id);
        return;
    }
 
    if (d->n_eff_sets == 1) {
        gsc_delete_effects_table(d->e);
        d->n_eff_sets = 0;
        GSC_FREE(d->e);
        GSC_FREE(d->eff_set_ids);
        d->e = NULL;
        d->eff_set_ids = NULL;
    } else {
        d->n_eff_sets--;
 
        gsc_delete_effects_table(d->e + which_ix);
        gsc_MarkerEffects* newE = gsc_malloc_wrap(sizeof(*d->e)*d->n_eff_sets,GSC_FALSE);
        if (newE == NULL) {
            gsc_MarkerEffects cleared = d->e[which_ix];
            for (GSC_ID_T i = which_ix; i < d->n_eff_sets-1; ++i) {
                d->e[i] = d->e[i+1];
            }
            d->e[d->n_eff_sets] = cleared;
        } else {
            memcpy(newE, d->e, sizeof(*d->e)*which_ix);
            memcpy(newE + which_ix, d->e + which_ix + 1, sizeof(*d->e)*(d->n_eff_sets - which_ix));
            GSC_FREE(d->e);
            d->e = newE;
        }
 
        gsc_EffectID* newIDs = gsc_malloc_wrap(sizeof(*d->eff_set_ids)*d->n_eff_sets,GSC_FALSE);
        if (newIDs == NULL) {
            for (GSC_ID_T i = which_ix; i < d->n_eff_sets-1; ++i) {
                d->eff_set_ids[i] = d->eff_set_ids[i+1];
            }
            d->eff_set_ids[d->n_eff_sets] = NO_EFFECTSET;
        } else {
            memcpy(newIDs, d->eff_set_ids, sizeof(*d->eff_set_ids)*which_ix);
            memcpy(newIDs + which_ix, d->eff_set_ids + which_ix + 1, sizeof(*d->eff_set_ids)*(d->n_eff_sets - which_ix));
            GSC_FREE(d->eff_set_ids);
            d->eff_set_ids = newIDs;
        }
    }
}
 
void gsc_delete_label(gsc_SimData* d, const gsc_LabelID which_label) {
    GSC_ID_T label_ix;
    if (which_label.id == GSC_NO_LABEL.id || 
            (label_ix = gsc_get_index_of_label(d, which_label)) == GSC_NA_LOCALX) {
        fprintf(stderr, "Nonexistent label %lu\n", (long unsigned int)which_label.id);
        return;
    }
 
    if (d->n_labels == 1) {
        // Delete 'em all
        d->n_labels = 0;
        GSC_FREE(d->label_ids);
        d->label_ids = NULL;
        GSC_FREE(d->label_defaults);
        d->label_defaults = NULL;
 
        gsc_AlleleMatrix* m = d->m;
        while (m != NULL) {
 
            GSC_FREE(m->labels[0]);
            GSC_FREE(m->labels);
            m->labels = NULL;
 
            m = m->next;
        }
 
    } else {
        // Reduce the list of labels in the gsc_SimData
        gsc_LabelID* new_label_ids = gsc_malloc_wrap(sizeof(gsc_LabelID) * (d->n_labels - 1),GSC_FALSE);
        if (new_label_ids == NULL) {
            for (GSC_ID_T i = label_ix; i < d->n_labels - 1; ++i) {
                d->label_ids[i] = d->label_ids[i+1];
            }
            d->label_ids[d->n_labels] = GSC_NO_LABEL;
        } else {
            memcpy(new_label_ids,d->label_ids,sizeof(*d->label_ids)*label_ix);
            memcpy(new_label_ids + label_ix,d->label_ids + label_ix + 1, sizeof(*d->label_ids)*(d->n_labels - 1 - label_ix));
            GSC_FREE(d->label_ids);
            d->label_ids = new_label_ids;
        }
 
        int* new_label_defaults = gsc_malloc_wrap(sizeof(int) * (d->n_labels - 1),GSC_FALSE);
        if (new_label_defaults == NULL) {
            for (GSC_ID_T i = label_ix; i < d->n_labels - 1; ++i) {
                d->label_defaults[i] = d->label_defaults[i+1];
            }
            // no need to overwrite default
        } else {
            memcpy(new_label_defaults,d->label_defaults,sizeof(*d->label_defaults)*label_ix);
            memcpy(new_label_defaults + label_ix,d->label_defaults + label_ix + 1, sizeof(*d->label_defaults)*(d->n_labels - 1 - label_ix));
            GSC_FREE(d->label_defaults);
            d->label_defaults = new_label_defaults;
        }
        d->n_labels --;
 
        // Remove the label from the gsc_AlleleMatrix linked list
        gsc_AlleleMatrix* m = d->m;
        while (m != NULL) {
            GSC_FREE(m->labels[label_ix]);
 
            m->n_labels = d->n_labels;
            int** new_label_lookups = gsc_malloc_wrap(sizeof(int*) * (m->n_labels),GSC_FALSE);
            if (new_label_lookups == NULL) {
                for (GSC_ID_T i = label_ix; i < m->n_labels; ++i) {
                    m->labels[i] = m->labels[i+1];
                }
                m->labels[m->n_labels + 1] = NULL;
            } else {
                memcpy(new_label_lookups, m->labels, sizeof(*m->labels)*label_ix);
                memcpy(new_label_lookups + label_ix, m->labels + label_ix + 1, sizeof(*m->labels)*(m->n_labels - label_ix));
                GSC_FREE(m->labels);
                m->labels = new_label_lookups;
            }
 
            m = m->next;
        }
    }
}
 
void gsc_delete_genome(gsc_KnownGenome* g) {
    if (g->marker_names != NULL) {
        for (GSC_GENOLEN_T i = 0; i < g->n_markers; i++) {
            if (g->marker_names[i] != NULL) {
                GSC_FREE(g->marker_names[i]);
            }
        }
        GSC_FREE(g->marker_names);
        g->marker_names = NULL;
    }
    if (g->names_alphabetical != NULL) {
        GSC_FREE(g->names_alphabetical);
        g->names_alphabetical = NULL;
    }
    g->n_markers = 0;
 
    if (g->map_ids != NULL) {
        GSC_FREE(g->map_ids);
        g->map_ids = NULL;
    }
 
    if (g->maps != NULL) {
        for (GSC_ID_T i = 0; i < g->n_maps; ++i) {
            gsc_delete_recombination_map_nointegrity(g->maps + i);
        }
        GSC_FREE(g->maps);
        g->maps = NULL;
    }
    g->n_maps = 0;
}
 
void gsc_delete_recombination_map(gsc_SimData* d, const gsc_MapID which_map) {
    GSC_ID_T map_ix;
    if (which_map.id == GSC_NO_LABEL.id || (map_ix = gsc_get_index_of_map(d, which_map)) == GSC_NA_IDX) {
        fprintf(stderr, "Nonexistent recombination map %lu\n", (long unsigned int) which_map.id);
        return;
    }
 
    if (d->genome.n_maps == 1) {
        GSC_FREE(d->genome.map_ids);
        d->genome.map_ids = NULL;
        gsc_delete_recombination_map_nointegrity(&d->genome.maps[0]);
        GSC_FREE(d->genome.maps);
        d->genome.maps = NULL;
        d->genome.n_maps = 0;
    } else {
        d->genome.n_maps--;
        gsc_delete_recombination_map_nointegrity(&d->genome.maps[map_ix]);
        gsc_RecombinationMap* tmplist = gsc_malloc_wrap(sizeof(*d->genome.maps)*d->genome.n_maps, GSC_FALSE);
        if (tmplist == NULL) {
            gsc_RecombinationMap clearedmap = d->genome.maps[map_ix];
            for (GSC_ID_T i = map_ix; i < d->genome.n_maps - 1; ++i) {
                d->genome.maps[i] = d->genome.maps[i+1];
            }
            d->genome.maps[d->genome.n_maps] = clearedmap;
        } else {
            memcpy(tmplist, d->genome.maps, sizeof(*d->genome.maps)*map_ix);
            memcpy(tmplist + map_ix, d->genome.maps + map_ix + 1, sizeof(*d->genome.maps)*(d->genome.n_maps - map_ix));
            GSC_FREE(d->genome.maps);
            d->genome.maps = tmplist;
        }
 
        gsc_MapID* tmpids = gsc_malloc_wrap(sizeof(*d->genome.map_ids)*d->genome.n_maps, GSC_FALSE);
        if (tmpids == NULL) {
            for (GSC_ID_T i = map_ix; i < d->genome.n_maps - 1; ++i) {
                d->genome.map_ids[i] = d->genome.map_ids[i+1];
            }
            d->genome.map_ids[d->genome.n_maps] = NO_MAP;
        } else {
            memcpy(tmpids, d->genome.map_ids, sizeof(*d->genome.map_ids)*map_ix);
            memcpy(tmpids + map_ix, d->genome.map_ids + map_ix + 1, sizeof(*d->genome.map_ids)*(d->genome.n_maps - map_ix));
            GSC_FREE(d->genome.map_ids);
            d->genome.map_ids = tmpids;
        }
    }
}
 
void gsc_delete_recombination_map_nointegrity(gsc_RecombinationMap* m) {
    if (m->chrs != NULL) {
        for (GSC_GENOLEN_T i = 0; i < m->n_chr; ++i) {
            switch (m->chrs[i].type) {
            case GSC_LINKAGEGROUP_SIMPLE:
                m->chrs[i].map.simple.expected_n_crossovers = 0;
                m->chrs[i].map.simple.first_marker_index = 0;
                m->chrs[i].map.simple.n_markers = 0;
                if (m->chrs[i].map.simple.dists != NULL) {
                    GSC_FREE(m->chrs[i].map.simple.dists);
                    m->chrs[i].map.simple.dists = NULL;
                }
                break;
            case GSC_LINKAGEGROUP_REORDER:
                m->chrs[i].map.reorder.expected_n_crossovers = 0;
                m->chrs[i].map.reorder.n_markers = 0;
                if (m->chrs[i].map.reorder.dists != NULL) {
                    GSC_FREE(m->chrs[i].map.reorder.dists);
                    m->chrs[i].map.reorder.dists = NULL;
                }
                if (m->chrs[i].map.reorder.marker_indexes != NULL) {
                    GSC_FREE(m->chrs[i].map.reorder.marker_indexes);
                    m->chrs[i].map.reorder.marker_indexes = NULL;
                }
                break;
            }
        }
        GSC_FREE(m->chrs);
        m->chrs = NULL;
    }
    if (m->chr_names != NULL) {
        for (GSC_GENOLEN_T i = 0; i < m->n_chr; ++i) {
            GSC_FREE(m->chr_names[i]);
        }
        GSC_FREE(m->chr_names);
        m->chr_names = NULL;
    }
    m->n_chr = 0;
}
 
void gsc_delete_allele_matrix(gsc_AlleleMatrix* m) {
    if (m == NULL) {
        return;
    }
    gsc_AlleleMatrix* next;
    while (m != NULL) {
        /* free the big data matrix */
        for (GSC_LOCALX_T i = 0; i < CONTIG_WIDTH; i++) {
            if (m->alleles[i] != NULL) {
                GSC_FREE(m->alleles[i]);
            }
 
        }
 
        // free names
        for (GSC_LOCALX_T i = 0; i < CONTIG_WIDTH; i++) {
            if (m->names[i] != NULL) {
                GSC_FREE(m->names[i]);
            }
        }
 
        // free labels
        for (GSC_ID_T i = 0; i < m->n_labels; ++i) {
            if (m->labels[i] != NULL) {
                GSC_FREE(m->labels[i]);
            }
        }
        if (m->labels != NULL) {
            GSC_FREE(m->labels);
        }
 
        next = m->next;
        GSC_FREE(m);
        m = next;
    }
}
 
void gsc_delete_effects_table(gsc_MarkerEffects* m) {
    m->n_markers = 0;
    if (m->centre != NULL) {
        GSC_FREE(m->centre);
        m->centre = NULL;
    }
    if (m->cumn_alleles != NULL) {
        GSC_FREE(m->cumn_alleles);
        m->cumn_alleles = NULL;
    }
    if (m->allele != NULL) {
        GSC_FREE(m->allele);
        m->allele = NULL;
    }
    if (m->eff != NULL) {
        GSC_FREE(m->eff);
        m->eff = NULL;
    }
}
 
void gsc_delete_simdata(gsc_SimData* m) {
    if (m != NULL) {
        // clear_simdata does a tiny bit of extra work compared to just freeing everything (by setting to 0)
        // but it's minor, and you won't be calling this function in a tight loop anyway
        gsc_clear_simdata(m); 
        GSC_FREE(m);
    }
}
 
void gsc_delete_markerblocks(gsc_MarkerBlocks* b) {
    for (GSC_ID_T i = 0; i < b->num_blocks; ++i) {
        GSC_FREE(b->markers_in_block[i]);
    }
    GSC_FREE(b->markers_in_block);
    b->markers_in_block = NULL;
    GSC_FREE(b->num_markers_in_block);
    b->num_markers_in_block = NULL;
    b->num_blocks = 0;
 
    return;
}
 
 
void gsc_delete_bidirectional_iter(gsc_BidirectionalIterator* it) {
    it->am = NULL;
    //it->group = GSC_NO_GROUP;
    it->localPos = GSC_NA_LOCALX;
    it->cachedAM = NULL;
    it->cachedAMIndex = UINT_MAX;
    it->atEnd = GSC_TRUE;
    it->atStart = GSC_TRUE;
}
 
void gsc_delete_randomaccess_iter(gsc_RandomAccessIterator* it) {
    it->d = NULL;
    //it->group = GSC_NO_GROUP;
    if (it->cacheSize > 0) {
        GSC_FREE(it->cache);
    }
    it->cache = NULL;
    it->cacheSize = 0;
    it->largestCached = GSC_NA_GLOBALX;
    it->groupSize = 0;
}
 
/*-------------------------------gsc_SimData loaders-----------------------------*/
 
gsc_TableFileReader gsc_tablefilereader_create(const char* filename) {
    FILE* fp;
    if ((fp = fopen(filename, "r")) == NULL) {
        fprintf(stderr, "Failed to open file %s.\n", filename);
    }
 
    gsc_TableFileReader tfr = { .fp = fp,
                                .buf = { 0 },
                                .buf_fill = 0,
                                .cursor = 0,
                              };
 
    if (fp != NULL) {
        tfr.buf_fill = fread(tfr.buf,1,sizeof(tfr.buf),fp);
    }
    return tfr;
}
 
void gsc_tablefilereader_close(gsc_TableFileReader* tbl) {
    if (tbl->fp != NULL) { fclose(tbl->fp); }
    tbl->fp = NULL;
}
 
void gsc_helper_tablefilereader_refill_buffer(gsc_TableFileReader* tbl) {
    tbl->cursor = 0;
    if (tbl->fp != NULL) {
        tbl->buf_fill = fread(tbl->buf,1,sizeof(tbl->buf),tbl->fp);
    } else {
        tbl->buf_fill = 0;
    }
}
 
enum gsc_TableFileCurrentStatus gsc_helper_tablefilereader_classify_char(gsc_TableFileReader* tbl) {
    if (tbl->buf_fill <= tbl->cursor) {
        if (tbl->buf_fill < sizeof(tbl->buf)) { // last read did not fill the entire buffer
            return GSC_TABLEFILE_ERROR_EOF;
        }
        return GSC_TABLEFILE_ERROR_EOBUF;
    }
 
    switch (tbl->buf[tbl->cursor]) {
    case '\r': // allow '\r' or '\r\n' as end of lines. also allow '\n' as end of line (see following case)
    case '\n':
        return GSC_TABLEFILE_NEWLINE;
    case '\t':
    case ' ':
    case ',':
        return GSC_TABLEFILE_COLUMNGAP;
    default:
        return GSC_TABLEFILE_CONTENTS;
    }
}
 
void gsc_tablefilecell_deep_copy(gsc_TableFileCell* c) {
    if (c->cell_len > 0 && c->isCellShallow) {
        char* deepcell = gsc_malloc_wrap(sizeof(char)*(c->cell_len+1), GSC_TRUE);
        memcpy(deepcell,c->cell,sizeof(char)*c->cell_len);
        deepcell[c->cell_len] = '\0';
        c->cell = deepcell;
        c->isCellShallow = GSC_FALSE;
    }
}
 
gsc_TableFileCell gsc_tablefilereader_get_next_cell(gsc_TableFileReader* tbl) {
    gsc_TableFileCell cur = { .isCellShallow = GSC_TRUE, .cell = NULL, .cell_len = 0,
                              .predCol = 0, .predNewline = 0, .eof = GSC_FALSE };
 
    GSC_CREATE_BUFFER(tmpcell,char,1);
    size_t tmpix = 0;
    size_t tblbuf_offset = 0;
    size_t tblbuf_len = 0;
    int predCarriageReturn = 0; // for detecting /r/n as a single "newline"
    _Bool warned = 0;
 
    while (1) {
        enum gsc_TableFileCurrentStatus type = gsc_helper_tablefilereader_classify_char(tbl);
        if (0 < predCarriageReturn) { --predCarriageReturn; } // decremented each time step
 
        if (0 == cur.cell_len) {
            switch (type) {
            case GSC_TABLEFILE_NEWLINE:
                if (tbl->buf[tbl->cursor] == '\r') {
                    predCarriageReturn = 2; // will have value 1 at next loop iteration, then will fall back to 0
                }
                if (!(predCarriageReturn && tbl->buf[tbl->cursor] == '\n')) {
                    ++cur.predNewline;
                }
                cur.predCol = 0;
                ++tbl->cursor;
                break;
 
            case GSC_TABLEFILE_COLUMNGAP:
                ++tbl->cursor;
                ++cur.predCol;
                break;
 
            case GSC_TABLEFILE_ERROR_EOBUF:
                // just refill as we have no contents we need to save yet
                gsc_helper_tablefilereader_refill_buffer(tbl);
                if (0 < predCarriageReturn) { ++predCarriageReturn; } // should not tick down the counter this loop iteration
                break;
 
            case GSC_TABLEFILE_CONTENTS:
                tblbuf_offset = tbl->cursor; tblbuf_len = 1; // in case we need to make a deep copy later.
                cur.cell = tbl->buf + tbl->cursor;
                ++cur.cell_len;
                ++tbl->cursor;
                break;
 
            default:
                ++tbl->cursor;
                cur.eof = GSC_TRUE;
                return cur;
            }
 
        } else { // have found the cell, just need to read the rest of it
            switch (type) {
            case GSC_TABLEFILE_CONTENTS:
                ++tbl->cursor;
                ++tblbuf_len;
                ++cur.cell_len;
                break;
 
            case GSC_TABLEFILE_ERROR_EOBUF:
                cur.isCellShallow = GSC_FALSE;
 
                if (!warned && tblbuf_len > 8192) {
                    warned = 1;
                    fprintf(stderr,"Warning: very long cell identified beginning %c%c%c%c%c%c. Column separators may have failed to be recognised\n",
                            tmpcell[0],tmpcell[1],tmpcell[2],tmpcell[3],tmpcell[4],tmpcell[5]);
                }
 
                GSC_STRETCH_BUFFER(tmpcell,tmpix + tblbuf_len + 1);
                memcpy(tmpcell+tmpix,tbl->buf+tblbuf_offset,sizeof(char)*tblbuf_len);
                tmpix += tblbuf_len;
                tmpcell[tmpix] = '\0';
 
                tblbuf_offset = 0; tblbuf_len = 0;
                gsc_helper_tablefilereader_refill_buffer(tbl);
                break;
 
            case GSC_TABLEFILE_ERROR_EOF:
                ++tbl->cursor;
                cur.eof = GSC_TRUE;
                // fall through
            default: // newline or column gap or end of file discovered: save and return.
                if (!cur.isCellShallow) {
                    cur.cell = gsc_malloc_wrap(sizeof(char)*(cur.cell_len + 1),GSC_TRUE);
                    memcpy(cur.cell,tmpcell,sizeof(char)*tmpix);
                    if (0 < tblbuf_len) {
                        memcpy(cur.cell+tmpix,tbl->buf+tblbuf_offset,sizeof(char)*tblbuf_len);
                    }
                    cur.cell[cur.cell_len] = '\0';
                    GSC_DELETE_BUFFER(tmpcell);
                }
                return cur;
            }
        }
    }
}
 
_Bool gsc_get_index_of_genetic_marker(const char* target, 
                                      gsc_KnownGenome g, 
                                      GSC_GENOLEN_T* out) {
    GSC_GENOLEN_T first = 0, last = g.n_markers - 1;
    GSC_GENOLEN_T index = (first + last) / 2;
    int comparison = strcmp(target,*(g.names_alphabetical[index]));
    while (comparison != 0 && first <= last) {
        if (comparison == 0) {
            if (out != NULL) *out = g.names_alphabetical[index] - g.marker_names;
            return 1;
        } else if (comparison > 0) {
            first = index + 1;
            if (first >= g.n_markers) { return 0; }
        } else {
            if (index == 0) { return 0; }
            last = index - 1;
        }
 
        // index has been updated, no matter the branch.
        index = (first + last) / 2;
        comparison = strcmp(target, *(g.names_alphabetical[index]));
    }
 
    if (first > last) {
        return 0;
    }
    if (out != NULL) *out = g.names_alphabetical[index] - g.marker_names;
    return 1;
}
 
static gsc_TableFileCell gsc_helper_tablefilereader_get_next_cell_wqueue(gsc_TableFileReader* tf, 
                                                                         gsc_TableFileCell** queue, 
                                                                         size_t* queuesize) {
    gsc_TableFileCell ncell;
    if (*queuesize > 0) {
        ncell = *queue[0];
        /*for (int i = 1; i < *queuesize; ++i) { *queue[i-1] = *queue[i]; }*/
        ++*queue;
        --*queuesize;
    } else {
        ncell = gsc_tablefilereader_get_next_cell(tf);
    }
    return ncell;
}
 
 
static int gsc_helper_read_first_row(gsc_TableFileReader* tf,
                                     int min_headerlen,
                                     int max_headerlen,
                                     gsc_TableFileCell* outputq,
                                     size_t* queuesize) {
    for (int i = 0; i < max_headerlen + 1; ++i) {
        // Read the next cell if it hasn't been read yet
        if (*queuesize <= i) {
            outputq[i] = gsc_tablefilereader_get_next_cell(tf);
            (*queuesize)++;
        }
        
        int headerlength = -1;
        if (outputq[i].predNewline) { // detected a newline after the previous cell 
            headerlength = i; 
        } else if (outputq[i].eof) { // detected end of file at the end of this cell
            headerlength = i+1; 
        }
        
        if (headerlength > 0) {
            if (headerlength >= min_headerlen && headerlength <= max_headerlen) {
                return headerlength;
            } else {
                return GSC_NA;
            }
            
        }
        
    }
    return GSC_NA;
}
 
 
static GSC_LOGICVAL gsc_helper_parse_ncell_header(int ncellrow1,
                                                  gsc_TableFileCell* unprocessedqueue,  
                                                  int ncell_required,
                                                  const char** titles_required,
                                                  int ncell_optional,
                                                  const char** titles_optional,
                                                  int* col_order) {
    // Check ordering of titles.
    // Step 1: Initialise
    int ncell_total = ncell_required + ncell_optional;
    for (int i = 0; i < ncell_total; ++i) {
        col_order[i] = i;
    }
    
    // Step 2: Check and save actual ordering of titles
    int title_ix = 0;
    for (; title_ix < ncell_required; ++title_ix) {
        // While we're checking required titles, we return FALSE/0 if we fail to find a match
        // for ANY required title inside the first row cells.
        // In searching through the first row cells, we should search through all indexes in 
        // col_order that are same position as title_ix or further along in the shuffled array.
        _Bool found_match = 0;
        size_t title_len = strlen(titles_required[title_ix]);
        
        for (int header_ix = title_ix; header_ix < ncellrow1; ++header_ix) {
            int header_queueix = col_order[header_ix];
            // If this cell number has the right title, swap its index to corresponding place
            if (unprocessedqueue[header_queueix].cell_len == title_len &&
                strncmp(unprocessedqueue[header_queueix].cell,titles_required[title_ix],title_len) == 0) {
                if (header_ix != title_ix) {
                    col_order[header_ix] = col_order[title_ix];
                    col_order[title_ix] = header_queueix;
                }
                found_match = 1;
                break;
            }
        }
        if (!found_match) { return GSC_FALSE; } // seems this isn't a header, we can't find required titles
    }
    int matches = ncell_required;
    for (; title_ix < ncell_total; ++title_ix) {
        // While we're checking optional titles, we set the col_order value of titles that have no
        // match in the first row cells to -1, but continue searching rather than returning immediately.
        // In searching through the first row cells, we search all indexes in the shuffled col_order
        // array that are greater than or equal to the number of titles matched so far.
        _Bool found_match = 0;
        int title_ix_o = title_ix - ncell_required;
        size_t title_len = strlen(titles_optional[title_ix_o]);
        
        for (int header_ix = matches; header_ix < ncellrow1; ++header_ix) {
            int header_queueix = col_order[header_ix];
            // If this cell number has the right title, swap its index to corresponding place
            if (unprocessedqueue[header_queueix].cell_len == title_len &&
                strncmp(unprocessedqueue[header_queueix].cell,titles_optional[title_ix_o],title_len) == 0) {
                if (header_ix != title_ix) {
                    col_order[header_ix] = col_order[title_ix];
                    col_order[title_ix] = header_queueix;
                }
                found_match = 1;
                ++matches;
                break;
            }
        }
        if (!found_match) { col_order[title_ix] = -1; }
    }
    return GSC_TRUE;
}
 
 
static size_t gsc_helper_parse_mapfile(const char* filename, struct gsc_MapfileUnit** out) {
    if (filename == NULL) return 0;
 
    gsc_TableFileReader tf = gsc_tablefilereader_create(filename);
 
    size_t row = 1;
    size_t col = 1;
 
    gsc_TableFileCell cellsread[4] = { 0 };
    gsc_TableFileCell* cellqueue = cellsread;
    size_t queue_size = 0;
    int row1len = gsc_helper_read_first_row(&tf, 3, 3, cellqueue, &queue_size);
    
    const char* titles[3] = { "marker", "chr", "pos"};
    int colnums[3];
    int marker_colnum, chr_colnum, pos_colnum;
    GSC_LOGICVAL header = (row1len == 3) ? gsc_helper_parse_ncell_header(row1len, cellqueue, 3, titles, 0, NULL, colnums) : GSC_NA;
    if (header == GSC_TRUE) {
        printf("(Loading %s) Format: map file with header\n", filename);
        marker_colnum = colnums[0] + 1, chr_colnum = colnums[1] + 1, pos_colnum = colnums[2] + 1;
    } else if (header == GSC_FALSE) {
        printf("(Loading %s) Format: map file without header\n", filename);
        marker_colnum = 1, chr_colnum = 2, pos_colnum = 3;
    } else {
        printf("(Loading %s) Failure: Cannot identify the expected 3 columns of the map file\n", filename);
        for (int i = 0; i < queue_size; ++i) {
            if (!cellqueue[i].isCellShallow) { GSC_FREE(cellqueue[i].cell); }
        }
        gsc_tablefilereader_close(&tf);
        return 0;
    }
 
    if (header) {
        cellqueue += 3;
        queue_size -= 3;
        if (!cellsread[0].isCellShallow) { GSC_FREE(cellsread[0].cell); }
        if (!cellsread[1].isCellShallow) { GSC_FREE(cellsread[1].cell); }
        if (!cellsread[2].isCellShallow) { GSC_FREE(cellsread[2].cell); }
    }
    _Bool goodrow = (header) ? 0 : 1; // discard first row if it's a header, keep if it's not.
    size_t goodrow_counter = 0;
 
    char* marker = NULL;
    char* chr = NULL;
    double pos = 0;
    char* conversionflag;
 
    GSC_CREATE_BUFFER(buffer,struct gsc_MapfileUnit,CONTIG_WIDTH);
 
    gsc_TableFileCell ncell;
    do {
        ncell = gsc_helper_tablefilereader_get_next_cell_wqueue(&tf, &cellqueue, &queue_size);
 
        // Update row/col position and save predecessor row
        if (ncell.cell != NULL) {
            if (ncell.predNewline) {
                if (goodrow) { // save predecessor row
                    buffer[goodrow_counter].name = marker;
                    buffer[goodrow_counter].chr  = chr;
                    buffer[goodrow_counter].pos  = pos;
 
                    ++goodrow_counter;
                    if (goodrow_counter >= buffercap) {
                        GSC_STRETCH_BUFFER(buffer,2*row);
                    }
                    marker = NULL;
                    chr = NULL;
                } else {
                    if (marker != NULL) {
                        GSC_FREE(marker);
                    }
                    if (chr != NULL) {
                        GSC_FREE(chr);
                    }
                }
                row += ncell.predNewline;
                goodrow = 1;
                col = 1;
            }
            col += (ncell.predCol > 0) ? 1 : 0;
 
            // Parse this cell
            if (ncell.cell_len == 0) {
                goodrow = 0;
            } if (col == marker_colnum) {
                gsc_tablefilecell_deep_copy(&ncell);
                marker = ncell.cell; ncell.cell = NULL;
                //ncell.isCellShallow = GSC_TRUE; // so it isn't freed.
 
            } else if (col == chr_colnum) {
                gsc_tablefilecell_deep_copy(&ncell);
                chr = ncell.cell; ncell.cell = NULL;
                //ncell.isCellShallow = GSC_TRUE; // so it isn't freed
                /*char tmp = ncell.cell[ncell.cell_len]; ncell.cell[ncell.cell_len] = '\0';
                chr = strtoul(ncell.cell,&conversionflag,36);
                ncell.cell[ncell.cell_len] = tmp;
                if (conversionflag != ncell.cell + ncell.cell_len) { // unsuccessful read
                    //fprintf(stderr,"Entry at row %i column %i of file %s could not be parsed as an integer or alphanumeric string\n", row, chr_colnum, filename);
                    goodrow = 0;
                }*/
 
            } else if (col == pos_colnum) {
                char tmp = ncell.cell[ncell.cell_len]; ncell.cell[ncell.cell_len] = '\0';
                pos = strtod(ncell.cell,&conversionflag);
                ncell.cell[ncell.cell_len] = tmp;
                if (conversionflag != ncell.cell + ncell.cell_len) { // unsuccessful read
                    goodrow = 0;
                    //fprintf(stderr,"Entry at row %i column %i of file %s could not be parsed as a numeric value\n", row, pos_colnum, filename);
                }
 
            } else {
                goodrow = 0;
            }
 
            // Reset to get next cell.
            if (!ncell.isCellShallow && ncell.cell != NULL) { GSC_FREE(ncell.cell); }
        }
    } while (!ncell.eof);
 
    if (col == 3) {
        if (goodrow) { // save predecessor row
            buffer[goodrow_counter].name = marker;
            buffer[goodrow_counter].chr  = chr;
            buffer[goodrow_counter].pos  = pos;
 
            ++goodrow_counter;
            marker = NULL;
        } else {
            if (marker != NULL) {
                GSC_FREE(marker);
            }
            if (chr != NULL) {
                GSC_FREE(chr);
            }
        }
    }
    //row -= ncell.predNewline; // don't count trailing newlines in stats.
 
    printf("(Loading %s) %u marker(s) with map positions were loaded. Failed to parse %u line(s).\n", filename, (unsigned int) goodrow_counter, (unsigned int) (row - header - goodrow_counter));
    gsc_tablefilereader_close(&tf);
 
    // Check outputs. We don't delete the buffers because we want to leave them alive with our callers holding the handles.
    GSC_FINALISE_BUFFER(buffer,*out,goodrow_counter);
    return goodrow_counter;
}
 
 
static GSC_GENOLEN_T gsc_helper_str_markerlist_leftjoin(gsc_KnownGenome g, 
                                                 GSC_GENOLEN_T n_markers_in_list, 
                                                 struct gsc_MapfileUnit** markerlist) {
    struct gsc_MapfileUnit* rlist = *markerlist;
    GSC_GENOLEN_T n_joined = 0;
    /*size_t consecutivity_bias; // we cache the index of the last name we found and pre-check whether the next marker
    // in the list is the next marker in the genome. For the case where people organise their genotype file and genetic
    // map file in the same order. Edit: decided this is not likely enough a situation to build this in.*/
 
    for (GSC_GENOLEN_T i = 0; i < n_markers_in_list; ++i) {
        if (rlist[i].name != NULL) {
            GSC_GENOLEN_T nameix;
            if (gsc_get_index_of_genetic_marker(rlist[i].name, g, &nameix)) {
                if (n_joined != i) {
                    rlist[n_joined] = rlist[i];
                }
                n_joined++;
 
            } else { // discard this marker. n_joined lags behind i by one more step.
                GSC_FREE(rlist[i].name);
                GSC_FREE(rlist[i].chr);
            }
        }
    }
 
    return n_joined;
}
 
 
static gsc_MapID gsc_helper_insert_recombmap_into_simdata(gsc_SimData* d, gsc_RecombinationMap map) {
    GSC_ID_T newmapindex = 0;
    if (d->genome.n_maps > 0) {
        newmapindex = d->genome.n_maps;
 
        gsc_MapID* tmpMapIDs = gsc_malloc_wrap(sizeof(gsc_MapID)*(newmapindex+1),GSC_TRUE);
        memcpy(tmpMapIDs,d->genome.map_ids,sizeof(gsc_MapID)*newmapindex);
        GSC_FREE(d->genome.map_ids);
        d->genome.map_ids = tmpMapIDs;
 
        gsc_RecombinationMap* tmpMaps = gsc_malloc_wrap(sizeof(gsc_RecombinationMap)*(newmapindex+1),GSC_TRUE);
        memcpy(tmpMaps,d->genome.maps,sizeof(gsc_RecombinationMap)*newmapindex);
        GSC_FREE(d->genome.maps);
        d->genome.maps = tmpMaps;
 
    } else {
        d->genome.map_ids = gsc_malloc_wrap(sizeof(gsc_MapID)*1,GSC_TRUE);
        d->genome.maps = gsc_malloc_wrap(sizeof(gsc_RecombinationMap)*1,GSC_TRUE);
    }
    d->genome.map_ids[newmapindex] = gsc_get_new_map_id(d);
    d->genome.n_maps++;
    d->genome.maps[newmapindex] = map;
 
    return d->genome.map_ids[newmapindex];
}
 
static gsc_EffectID gsc_helper_insert_eff_set_into_simdata(gsc_SimData* d, gsc_MarkerEffects effset) {
    GSC_ID_T neweffsetindex = 0;
    if (d->n_eff_sets > 0) {
        neweffsetindex = d->n_eff_sets;
 
        gsc_EffectID* tmpIDs = gsc_malloc_wrap(sizeof(gsc_EffectID)*(neweffsetindex+1),GSC_TRUE);
        memcpy(tmpIDs,d->eff_set_ids,sizeof(gsc_EffectID)*neweffsetindex);
        GSC_FREE(d->eff_set_ids);
        d->eff_set_ids = tmpIDs;
 
        gsc_MarkerEffects* tmpMats = gsc_malloc_wrap(sizeof(*tmpMats)*(neweffsetindex+1),GSC_TRUE);
        memcpy(tmpMats,d->e,sizeof(*tmpMats)*neweffsetindex);
        GSC_FREE(d->e);
        d->e = tmpMats;
 
    } else {
        d->eff_set_ids = gsc_malloc_wrap(sizeof(gsc_EffectID)*1,GSC_TRUE);
        d->e = gsc_malloc_wrap(sizeof(gsc_MarkerEffects)*1,GSC_TRUE);
    }
    d->eff_set_ids[neweffsetindex] = gsc_get_new_eff_set_id(d);
    d->n_eff_sets++;
    d->e[neweffsetindex] = effset;
 
    return d->eff_set_ids[neweffsetindex];
}
 
static void gsc_helper_sort_markerlist(GSC_GENOLEN_T n_markers, struct gsc_MapfileUnit* markerlist) {
    if (n_markers < 2) { return; }
 
    // sort by linkage group
    qsort(markerlist,n_markers,sizeof(*markerlist),gsc_helper_mapfileunit_ascending_chr_comparer);
 
    // sort each linkage group by pos
    //int n_chr = 1;
    GSC_GENOLEN_T chr_start = 0;
    char* current_chr = markerlist[0].chr;
 
    for (GSC_GENOLEN_T i = 1; i < n_markers; ++i) {
        if (strcmp(markerlist[i].chr, current_chr) != 0) { // found end of current chr
            //n_chr++;
            qsort(markerlist + chr_start, i - chr_start,
                    sizeof(*markerlist), gsc_helper_mapfileunit_ascending_d_comparer);
 
            chr_start = i;
            current_chr = markerlist[i].chr;
        }
    }
 
    qsort(markerlist + chr_start, n_markers - chr_start,
            sizeof(*markerlist), gsc_helper_mapfileunit_ascending_d_comparer);
    //return n_chr;
}
 
gsc_MapID gsc_create_recombmap_from_markerlist(gsc_SimData* d, 
                                               GSC_GENOLEN_T n_markers, 
                                               struct gsc_MapfileUnit* markerlist) {
    if (n_markers == 0) return NO_MAP;
 
    GSC_CREATE_BUFFER(chr_nmembers,GSC_GENOLEN_T,40);
    memset(chr_nmembers,0,sizeof(*chr_nmembers)*40);
    GSC_CREATE_BUFFER(chr_ids,char*,40);
    chr_nmembers[0] = 1;
    GSC_GENOLEN_T n_chr = 1;
    chr_ids[n_chr-1] = markerlist[0].chr; 
    markerlist[0].chr = NULL; // so that it will not be freed
    for (GSC_GENOLEN_T i = 1; i < n_markers; ++i) {
        while (i < n_markers && markerlist[i].name == NULL) {
            ++i;
        }
        if (strcmp(chr_ids[n_chr-1], markerlist[i].chr) != 0) {
            // First of next
            if (n_chr >= chr_nmemberscap) {
                GSC_STRETCH_BUFFER(chr_ids,2*n_chr);
                GSC_STRETCH_BUFFER(chr_nmembers,2*n_chr);
                memset(chr_nmembers+n_chr,0,sizeof(*chr_nmembers)*n_chr);
            }
            ++n_chr;
            chr_ids[n_chr-1] = markerlist[i].chr;
            markerlist[i].chr = NULL;
            chr_nmembers[n_chr-1] = 1;
        } else {
            ++(chr_nmembers[n_chr-1]);
        }
    }
 
    gsc_RecombinationMap map = {.n_chr=n_chr, 
                                .chr_names=NULL,
                                .chrs=gsc_malloc_wrap(sizeof(gsc_LinkageGroup) * n_chr, GSC_TRUE) };
    GSC_FINALISE_BUFFER(chr_ids,map.chr_names,n_chr);
 
    // Populate the map. Each chr/linkage group may be "Simple" or "Reordered"
    GSC_GENOLEN_T could_not_match = 0;
    GSC_GENOLEN_T current_marker = 0;
    GSC_GENOLEN_T first_marker;
    GSC_GENOLEN_T n_bad_chr = 0;
    GSC_GENOLEN_T n_sparse_chr = 0;
    for (GSC_GENOLEN_T chr_ix = 0; chr_ix < map.n_chr; ++chr_ix) {      
        first_marker = current_marker;
        double chrdist = markerlist[first_marker + chr_nmembers[chr_ix] - 1].pos - markerlist[first_marker].pos;
        double* lgdists = gsc_malloc_wrap(sizeof(double)*(chr_nmembers[chr_ix]),GSC_TRUE);
 
        char found_first = GSC_FALSE;
        // n_goodmembers == 0 is a guard on firsts_coord_in_genome, but we 
        // still initialise it here (to a value too high to be reasonable)
        // because the compiler can't tell that.
        GSC_GENOLEN_T firsts_coord_in_genome = d->genome.n_markers; 
        GSC_GENOLEN_T n_goodmembers = 0;
        GSC_GENOLEN_T* marker_coords = NULL;
 
        GSC_GENOLEN_T endpt = first_marker + chr_nmembers[chr_ix];
        for (; current_marker < endpt; ++current_marker) { // simple recombination map, if possible
            if (markerlist[current_marker].name == NULL) {
                continue;
            }
 
            if (!found_first) {
                GSC_GENOLEN_T coord;
                if (!gsc_get_index_of_genetic_marker(markerlist[current_marker].name, d->genome, &coord)) {
                    could_not_match++;
                } else {
                    found_first = GSC_TRUE;
                    first_marker = current_marker;
                    firsts_coord_in_genome = coord;
                    lgdists[n_goodmembers] = (markerlist[current_marker].pos - markerlist[first_marker].pos) / chrdist;
                    n_goodmembers++;
                }
            } else if (firsts_coord_in_genome + n_goodmembers < d->genome.n_markers &&
                       strcmp(markerlist[current_marker].name, d->genome.marker_names[firsts_coord_in_genome + n_goodmembers]) == 0) {
                // we are a simple linkage group still so far.
                lgdists[n_goodmembers] = (markerlist[current_marker].pos - markerlist[first_marker].pos) / chrdist;
                n_goodmembers++;
            } else {
                // Just discovered we are a reordered linkage group. Copy over the marker indexes that were as expected.
                marker_coords = gsc_malloc_wrap(sizeof(*marker_coords)*(chr_nmembers[chr_ix]),GSC_TRUE);
                for (GSC_GENOLEN_T backfill = 0; backfill < n_goodmembers; ++backfill) {
                    marker_coords[backfill] = firsts_coord_in_genome + backfill;
                }
                break;
            }
 
        }
        for (; current_marker < endpt; ++current_marker) { // reordered recombination map, if previous failed.
            if (markerlist[current_marker].name == NULL) {
                continue;
            }
 
            GSC_GENOLEN_T coord;
            if (!gsc_get_index_of_genetic_marker(markerlist[current_marker].name, d->genome, &coord)) {
                ++could_not_match;
            } else {
                marker_coords[n_goodmembers] = coord;
                lgdists[n_goodmembers] = (markerlist[current_marker].pos - markerlist[first_marker].pos) / chrdist;
                ++n_goodmembers;
            }
        }
 
        if (n_goodmembers == 0) { // || firsts_coord_in_genome >= d->genome.n_markers) {
            n_bad_chr++;
        } else if (marker_coords == NULL) {
            GSC_GENOLEN_T chr_ix_actual = chr_ix-n_bad_chr;
            map.chrs[chr_ix_actual].type = GSC_LINKAGEGROUP_SIMPLE;
            map.chrs[chr_ix_actual].map.simple.expected_n_crossovers = chrdist / 100;
            map.chrs[chr_ix_actual].map.simple.n_markers = n_goodmembers;
            map.chrs[chr_ix_actual].map.simple.first_marker_index = firsts_coord_in_genome;
            map.chrs[chr_ix_actual].map.simple.dists = lgdists;
        } else {
            GSC_GENOLEN_T chr_ix_actual = chr_ix-n_bad_chr;
            map.chrs[chr_ix_actual].type = GSC_LINKAGEGROUP_REORDER;
            map.chrs[chr_ix_actual].map.reorder.expected_n_crossovers = chrdist / 100;
            map.chrs[chr_ix_actual].map.reorder.n_markers = n_goodmembers;
            map.chrs[chr_ix_actual].map.reorder.marker_indexes = marker_coords;
            map.chrs[chr_ix_actual].map.reorder.dists = lgdists;
        }
        if (chrdist >= 5000*n_goodmembers) { ++n_sparse_chr; }
    }
    GSC_DELETE_BUFFER(chr_nmembers);
    map.n_chr = map.n_chr-n_bad_chr;
    if (map.n_chr == 0) {
        GSC_FREE(map.chrs);
        return NO_MAP;
    }
    if (n_sparse_chr > 0) {
        fprintf(stderr,"%d of this map's chromosomes are very sparse (averaging less than 1 marker "
            "per 5 Morgans of distance). If the map is not expected to be this sparse, check that "
            "positions in the map file are in centimorgans, not base pairs.\n", n_sparse_chr);
    }
    return gsc_helper_insert_recombmap_into_simdata(d, map);
}
 
 
gsc_MapID gsc_create_uniformspaced_recombmap(gsc_SimData* d, 
                                             GSC_GENOLEN_T n_markers, 
                                             char** markernames, 
                                             double expected_n_recombinations) {
    if (d->genome.n_markers == 0) { 
        fprintf(stderr, "Cannot create a recombination map if there is no genome\n");
        return NO_MAP;
    } 
    
    gsc_RecombinationMap map = {.n_chr=1, .chr_names=NULL, .chrs=gsc_malloc_wrap(sizeof(gsc_LinkageGroup)*1, GSC_TRUE) };
 
    if (markernames == NULL) {
        double* lgdists = gsc_malloc_wrap(sizeof(double)*d->genome.n_markers,GSC_TRUE);
        double lgdist = 1./(d->genome.n_markers-1);
        lgdists[0] = 0;
        for (GSC_GENOLEN_T i = 1; i < d->genome.n_markers; ++i) { lgdists[i] = lgdists[i-1] + lgdist; }
 
        map.chrs[0].type = GSC_LINKAGEGROUP_SIMPLE;
        map.chrs[0].map.simple.expected_n_crossovers = expected_n_recombinations;
        map.chrs[0].map.simple.n_markers = d->genome.n_markers;
        map.chrs[0].map.simple.first_marker_index = 0;
        map.chrs[0].map.simple.dists = lgdists;
    } else {
        if (n_markers == 0) return NO_MAP;
 
        // markernames could still be simple or reordered compared to the d->genome, so need to check that first.
        _Bool found_first = 0;
        GSC_GENOLEN_T could_not_match = 0;
        GSC_GENOLEN_T firsts_coord_in_genome = d->genome.n_markers;
        GSC_GENOLEN_T chrmarker_ix = 0;
 
        GSC_GENOLEN_T* marker_coords = NULL;
        for (GSC_GENOLEN_T i = 0; i < n_markers; ++i) {
            if (!found_first || marker_coords != NULL) {
                // We are first or we are a reordered linkage group. Find what index in the genome the next marker is stored at.
                GSC_GENOLEN_T coord;
 
                if (markernames[i] == NULL) {
                    could_not_match++;
                } else if (!gsc_get_index_of_genetic_marker(markernames[i], d->genome, &coord )) {
                    could_not_match++;
                } else if (!found_first) {
                    found_first = 1;
                    firsts_coord_in_genome = coord;
                    chrmarker_ix++;
                } else { // must be the case that we have marker_coords != NULL and are a reordered linkage group
                    marker_coords[chrmarker_ix] = coord;
                    chrmarker_ix++;
                }
 
            } else if (firsts_coord_in_genome < d->genome.n_markers && 
                    strcmp(markernames[i], d->genome.marker_names[firsts_coord_in_genome + i]) == 0) {
                // are a simple linkage group still so far.
                chrmarker_ix++;
 
            } else {
                // Just discovered we are a reordered linkage group. Copy over the marker indexes that were as expected.
                marker_coords = gsc_malloc_wrap(sizeof(*marker_coords)*n_markers,GSC_TRUE);
                for (GSC_GENOLEN_T backfill = 0; backfill < chrmarker_ix; ++backfill) {
                    marker_coords[backfill] = firsts_coord_in_genome + backfill;
                }
 
                if (markernames[i] == NULL) {
                    could_not_match++;
                } else if  (!gsc_get_index_of_genetic_marker(markernames[i], d->genome, &(marker_coords[chrmarker_ix]) )) {
                    could_not_match++;
                } else {
                    chrmarker_ix++;
                }
            }
        }
 
        double* lgdists = gsc_malloc_wrap(sizeof(double)*chrmarker_ix,GSC_TRUE);
        double lgdist = 1./(chrmarker_ix-1);
        lgdists[0] = 0;
        for (GSC_GENOLEN_T i = 1; i < chrmarker_ix; ++i) { lgdists[i] = lgdists[i-1] + lgdist; }
 
        if (marker_coords == NULL) {
            map.chrs[0].type = GSC_LINKAGEGROUP_SIMPLE;
            map.chrs[0].map.simple.expected_n_crossovers = expected_n_recombinations;
            map.chrs[0].map.simple.n_markers = chrmarker_ix;
            map.chrs[0].map.simple.first_marker_index = firsts_coord_in_genome;
            map.chrs[0].map.simple.dists = lgdists;
        } else {
            map.chrs[0].type = GSC_LINKAGEGROUP_REORDER;
            map.chrs[0].map.reorder.expected_n_crossovers = expected_n_recombinations;
            map.chrs[0].map.reorder.n_markers = chrmarker_ix;
            map.chrs[0].map.reorder.marker_indexes = marker_coords;
            map.chrs[0].map.reorder.dists = lgdists;
        }
        
        if (could_not_match > 0) {
            fprintf(stderr, "%d of the marker names do not appear in the genome\n", could_not_match);
        }
        
    }
 
    return gsc_helper_insert_recombmap_into_simdata(d,map);
}
 
 
gsc_MapID gsc_create_unlinked_recombmap(gsc_SimData* d, GSC_GENOLEN_T n_markers, char** markernames) {
    if (d->genome.n_markers == 0) { 
        fprintf(stderr, "Cannot create a recombination map if there is no genome\n");
        return NO_MAP;
    } 
    
    if (markernames == NULL) {
        n_markers = d->genome.n_markers;
        //markernames = d->genome.marker_names;
        
        gsc_RecombinationMap map = {.n_chr=n_markers, .chr_names=NULL,
                                    .chrs=gsc_malloc_wrap(sizeof(gsc_LinkageGroup)*n_markers, GSC_TRUE) };
        
        for (GSC_GENOLEN_T i = 0; i < n_markers; ++i) {
            map.chrs[i].type = GSC_LINKAGEGROUP_SIMPLE;
            map.chrs[i].map.simple.n_markers = 1;
            map.chrs[i].map.simple.first_marker_index = i;
 
            // Lines below are dependent on pulling crossover counts from Poisson dist in generate_gamete, 
            // so that .expected_n_crossovers = 0 means .dists will never be accessed
            map.chrs[i].map.simple.expected_n_crossovers = 0; 
            map.chrs[i].map.simple.dists = NULL;
        }
        return gsc_helper_insert_recombmap_into_simdata(d,map);
        
    } else { // we've been given a list of markers. Our task is slightly more complex. 
        
        // First find all marker name indexes:
        GSC_CREATE_BUFFER(m_ix, GSC_GENOLEN_T, n_markers);
        GSC_GENOLEN_T n_good = 0;
        GSC_GENOLEN_T could_not_match = 0;
        for (GSC_GENOLEN_T m = 0; m < n_markers; ++m) {
             if (markernames[m] == NULL) {
                could_not_match++;
            } else if (!gsc_get_index_of_genetic_marker(markernames[m], d->genome, &m_ix[n_good] )) {
                could_not_match++;
            } else {
                ++n_good;
            }
        }
        if (could_not_match > 0) {
            fprintf(stderr, "%d of the marker names do not appear in the genome\n", could_not_match);
        }
        
        // Then create and populate the map 
        gsc_RecombinationMap map = {.n_chr=n_good, 
                                    .chrs=gsc_malloc_wrap(sizeof(gsc_LinkageGroup)*n_good, GSC_TRUE) };
        for (GSC_GENOLEN_T i = 0; i < n_good; ++i) {
            map.chrs[i].type = GSC_LINKAGEGROUP_SIMPLE;
            map.chrs[i].map.simple.n_markers = 1;
            map.chrs[i].map.simple.first_marker_index = m_ix[i];
 
            // Lines below are dependent on pulling crossover counts from Poisson dist in generate_gamete, 
            // so that .expected_n_crossovers = 0 means .dists will never be accessed
            map.chrs[i].map.simple.expected_n_crossovers = 0;
            map.chrs[i].map.simple.dists = NULL;
        }
        
        GSC_DELETE_BUFFER(m_ix);
        return gsc_helper_insert_recombmap_into_simdata(d,map);
    }
}
 
 
gsc_MapID gsc_load_mapfile(SimData* d, const char* filename) {
    if (filename == NULL) return NO_MAP;
 
    struct gsc_MapfileUnit* mapcontents = NULL;
    size_t nrows = gsc_helper_parse_mapfile(filename,&mapcontents);
    if (nrows == 0 || mapcontents == NULL) {
        if (mapcontents != NULL) {
            GSC_FREE(mapcontents);
        }
        return NO_MAP;
    }
 
    _Bool freeMapNames = 1;
    if (d->genome.n_markers > 0) {
        // if genome is already set, leftjoin on those markers.
        GSC_GENOLEN_T new_nrows = gsc_helper_str_markerlist_leftjoin(d->genome, nrows, &mapcontents);
        if (new_nrows < nrows) {
            printf("Discarded %lu markers when loading map %s because they do not appear in the primary map.\n", (long unsigned int) (nrows - new_nrows), filename);
        }
        nrows = new_nrows;
        gsc_helper_sort_markerlist(nrows,mapcontents);
    } else {
        // else set up the list of markers tracked by the simulation
        gsc_helper_sort_markerlist(nrows,mapcontents);
        d->genome = (gsc_KnownGenome){
            .n_markers = nrows,
            .marker_names = gsc_malloc_wrap(sizeof(char**)*nrows,GSC_TRUE),
            .names_alphabetical = gsc_malloc_wrap(sizeof(char**)*nrows,GSC_TRUE),
            .n_maps = 0,
            .map_ids = NULL,
            .maps = NULL
        };
        for (GSC_GENOLEN_T i = 0; i < d->genome.n_markers; ++i) {
            d->genome.marker_names[i] = mapcontents[i].name;
            d->genome.names_alphabetical[i] = &(d->genome.marker_names[i]);
        }
        qsort(d->genome.names_alphabetical,d->genome.n_markers,sizeof(*d->genome.names_alphabetical),gsc_helper_indirect_alphabetical_str_comparer);
 
        // Want to raise a warning if any marker names are repeated. One quick scan through.
        int n_dups = 0;
        for (GSC_GENOLEN_T i = 1; i < d->genome.n_markers; ++i) {
            if (strcmp(*d->genome.names_alphabetical[i-1],*d->genome.names_alphabetical[i]) == 0) { ++n_dups; }
        }
        if (n_dups > 0) {
            fprintf(stderr,"%d marker names were duplicates. It is recommended to remove duplicate names from the map file "
                "because data will only be loaded into one of the duplicates.\n", n_dups);
        }
 
        freeMapNames = 0;
        //printf( "Warning: loading genetic map before loading any founder genotypes. Many simulation operations will not yet run.\n");
    }
 
    gsc_MapID map = gsc_create_recombmap_from_markerlist(d, nrows, mapcontents);
    if (freeMapNames) {
        for (size_t i = 0; i < nrows; ++i) {
            GSC_FREE(mapcontents[i].name);
        }
    }
    for (size_t i = 0; i < nrows; ++i) { // free the chr names that haven't been moved to the proper map object
        if (mapcontents[i].chr != NULL) { GSC_FREE(mapcontents[i].chr); }
    }
    GSC_FREE(mapcontents);
 
    return map;
}
 
 
gsc_EffectID gsc_load_effectfile(gsc_SimData* d, const char* filename) {
    if (filename == NULL) return GSC_NO_EFFECTSET;
    if (d->genome.n_markers == 0) return GSC_NO_EFFECTSET;
 
    gsc_TableFileReader tf = gsc_tablefilereader_create(filename);
 
    size_t row = 1;
    size_t col = 1;
 
    gsc_TableFileCell cellsread[5] = { 0 };
    gsc_TableFileCell* cellqueue = cellsread;
    size_t queuesize = 0;
    int row1len = gsc_helper_read_first_row(&tf, 3, 4, cellqueue, &queuesize);
 
    const char* titles[4] = { "marker", "allele", "eff", "centre"};
    int colnums[4];
    int marker_colnum, allele_colnum, eff_colnum, centre_colnum;
    GSC_LOGICVAL header = gsc_helper_parse_ncell_header(row1len, cellqueue, 3, titles, 1, titles+3, colnums);
    if (header == GSC_TRUE) {
        printf("(Loading %s) Format: effect file with header\n", filename);
        marker_colnum = colnums[0] + 1, allele_colnum = colnums[1] + 1, eff_colnum = colnums[2] + 1;
        centre_colnum = colnums[3] + 1; // might be 0 if the column does not exist.
    } else if (header == GSC_FALSE) {
        printf("(Loading %s) Format: effect file without header\n", filename);
        marker_colnum = 1, allele_colnum = 2, eff_colnum = 3;
        // 3 + 1: number of official titles plus the one from the second line
        centre_colnum = (row1len > 3) ? 4 : 0;
    } else {
        printf("(Loading %s) Failure: Cannot identify the 3 required columns of the effect file\n", filename);
        gsc_tablefilereader_close(&tf);
        return NO_EFFECTSET;
    }
    
    if (centre_colnum > 0) {
        printf("(Loading %s) The file has %d columns. Identified optional column \"centre\"\n", filename, row1len);
    }
 
    if (header) {
        cellqueue += row1len;
        queuesize -= row1len;
        for (int i = 0; i < row1len; ++i) {
            if (!cellsread[i].isCellShallow) { GSC_FREE(cellsread[i].cell); }
        }
    }
    _Bool goodrow = (header) ? 0 : 1; // discard first row if it's a header, keep if it's not.
 
    GSC_CREATE_BUFFER(raweffects,struct gsc_EffectfileUnit,d->genome.n_markers);
    GSC_GENOLEN_T n_effects = 0;
    
    char* conversionflag;
    gsc_TableFileCell ncell;
    
    do {
        ncell = gsc_helper_tablefilereader_get_next_cell_wqueue(&tf, &cellqueue, &queuesize);
 
        if (ncell.cell != NULL) { // so that we can cope with missing final newline
            if (ncell.predNewline) {
                // save predecessor row then update row/col position
                if (goodrow && col >= row1len) {
                    ++n_effects;
                    if (n_effects >= raweffectscap) {
                        GSC_STRETCH_BUFFER(raweffects,2*n_effects);
                    }
                }
                
                row += ncell.predNewline;
                goodrow = 1;
                col = 1;
            }
            col += (ncell.predCol > 0) ? 1 : 0; // multiple column spacers treated as one
            
            if (ncell.cell_len == 0) {
                goodrow = 0;
            } else if (col == marker_colnum) {
                char tmp = ncell.cell[ncell.cell_len]; ncell.cell[ncell.cell_len] = '\0';
                _Bool validmarker = gsc_get_index_of_genetic_marker(ncell.cell,d->genome,
                                                                    &(raweffects[n_effects].markerix));
                ncell.cell[ncell.cell_len] = tmp;
                if (!validmarker) {
                    goodrow = 0;
                    //fprintf(stderr,"Entry at row %i column %i of file %s does not match the name of a tracked marker\n", row, marker_colnum, filename);
                }
 
            } else if (col == allele_colnum) {
                if (ncell.cell_len > 1) {
                    goodrow = 0;
                    //fprintf(stderr,"Entry at row %i column %i of file %s was too long to represent a single allele\n", row, allele_colnum, filename);
                } else {
                    raweffects[n_effects].allele = ncell.cell[0];
                }
 
            } else if (col == eff_colnum) {
                char tmp = ncell.cell[ncell.cell_len]; ncell.cell[ncell.cell_len] = '\0';
                raweffects[n_effects].eff = strtod(ncell.cell,&conversionflag);
                ncell.cell[ncell.cell_len] = tmp;
                if (conversionflag != ncell.cell + ncell.cell_len) { // unsuccessful read
                    goodrow = 0;
                    //fprintf(stderr,"Entry at row %i column %i of file %s could not be parsed as a numeric value\n", row, eff_colnum, filename);
                }
                
            } else if (col == centre_colnum) {
                char tmp = ncell.cell[ncell.cell_len]; ncell.cell[ncell.cell_len] = '\0';
                raweffects[n_effects].centre = strtod(ncell.cell,&conversionflag);
                ncell.cell[ncell.cell_len] = tmp;
                if (conversionflag != ncell.cell + ncell.cell_len) { // unsuccessful read
                    goodrow = 0;
                    //fprintf(stderr,"Entry at row %i column %i of file %s could not be parsed as a numeric value\n", row, eff_colnum, filename);
                }
            
            } else {
                goodrow = 0;
            }
            
            // Reset
            if (!ncell.isCellShallow) { GSC_FREE(ncell.cell); }
        }
    } while (!ncell.eof);           
    
    if (goodrow && col >= row1len) { // the final row, potentially.
        ++n_effects;
    }
 
    printf("(Loading %s) %lu effect value(s) were loaded. Failed to parse %lu line(s).\n", 
           filename, (long unsigned int) n_effects, (long unsigned int) (row - header - n_effects));
    gsc_tablefilereader_close(&tf);
 
    if (n_effects == 0) {
        GSC_DELETE_BUFFER(raweffects);
        return GSC_NO_EFFECTSET;
    }
        
    // now sort the raweffects based on markerix
    qsort(raweffects,n_effects,sizeof(*raweffects),gsc_helper_effectfileunit_ascending_mix_comparer);
    
    // Create empty marker effects 
    gsc_MarkerEffects e = { 0 };
    e.n_markers = d->genome.n_markers;
    e.cumn_alleles = gsc_malloc_wrap(sizeof(*e.cumn_alleles)*e.n_markers, GSC_TRUE);
    e.allele = gsc_malloc_wrap(sizeof(*e.allele)*n_effects, GSC_TRUE);
    e.eff = gsc_malloc_wrap(sizeof(*e.eff)*n_effects, GSC_TRUE);
    if (centre_colnum) {
        e.centre = gsc_malloc_wrap(sizeof(*e.centre)*e.n_markers, GSC_TRUE);
        for (GSC_GENOLEN_T i = 0; i < e.n_markers; ++i) {
            e.centre[i] = 0;
        }
    } else {
        e.centre = NULL;
    }
    
    // Populate MarkerEffects
    if (centre_colnum) { // conditional moved outside of inner loop
        GSC_GENOLEN_T markerix_current = 0;
        for (GSC_GENOLEN_T i = 0; i < n_effects; ++i) {
            if (raweffects[i].markerix != markerix_current) {
                for (GSC_GENOLEN_T j = markerix_current; j < raweffects[i].markerix; ++j) {
                    e.cumn_alleles[j] = i;
                }
                markerix_current = raweffects[i].markerix;
            }
            
            e.allele[i] = raweffects[i].allele;
            e.eff[i] = raweffects[i].eff;
            e.centre[markerix_current] += raweffects[i].centre * raweffects[i].eff; // line that differs
        }
        for (GSC_GENOLEN_T j = markerix_current; j < e.n_markers; ++j) {
            e.cumn_alleles[j] = n_effects;
        }
    } else {
        GSC_GENOLEN_T markerix_current = 0;
        for (GSC_GENOLEN_T i = 0; i < n_effects; ++i) {
            if (raweffects[i].markerix != markerix_current) {
                for (GSC_GENOLEN_T j = markerix_current; j < raweffects[i].markerix; ++j) {
                    e.cumn_alleles[j] = i;
                }
                markerix_current = raweffects[i].markerix;
            }
            
            e.allele[i] = raweffects[i].allele;
            e.eff[i] = raweffects[i].eff;
        }
        for (GSC_GENOLEN_T j = markerix_current; j < e.n_markers; ++j) {
            e.cumn_alleles[j] = n_effects;
        }
    }
        
    GSC_DELETE_BUFFER(raweffects);
    return gsc_helper_insert_eff_set_into_simdata(d, e);
}
 
static enum gsc_GenotypeFileCellStyle gsc_helper_genotype_matrix_identify_cell_style(gsc_TableFileCell c) {
    switch (c.cell_len) {
    case 1:
        switch (c.cell[0]) {
        case '0':
        case '1':
        case '2':
            return GSC_GENOTYPECELLSTYLE_COUNT;
        case 'G': // G
        case 'A': // A
        case 'T': // T
        case 'C': // C
        case 'R': // G/A
        case 'Y': // T/C
        case 'M': // A/C
        case 'K': // G/T
        case 'S': // G/C
        case 'W': // A/T
        case 'N': // any
            return GSC_GENOTYPECELLSTYLE_ENCODED;
        default:
            break;
        }
        break;
    case 2:
        if (c.cell[0] == 'm') { // m[numeric] case, which is probably a marker not an allele pair
            switch (c.cell[1]) {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                return GSC_GENOTYPECELLSTYLE_UNKNOWN;
            default:
                break;
            }
        }
        return GSC_GENOTYPECELLSTYLE_PAIR;
    case 3:
        if (c.cell[1] == '/') {
            return GSC_GENOTYPECELLSTYLE_SLASHPAIR;
        }
        break;
    default:
        break;
    }
    return GSC_GENOTYPECELLSTYLE_UNKNOWN;
}
 
static void gsc_helper_genotypecell_to_allelematrix(GenoLocation loc, 
                                                    GSC_GENOLEN_T markerix,
                                                    enum gsc_GenotypeFileCellStyle style, 
                                                    char* cell, 
                                                    gsc_SimData* forrng) {
    char* pos = loc.localAM->alleles[loc.localPos] + 2*markerix;
    int phase = 0;
    switch (style) {
    case GSC_GENOTYPECELLSTYLE_PAIR:
        pos[0] = cell[0];
        pos[1] = cell[1];
        break;
    case GSC_GENOTYPECELLSTYLE_SLASHPAIR:
        pos[0] = cell[0];
        pos[1] = cell[2];
        break;
    case GSC_GENOTYPECELLSTYLE_COUNT:
        switch (cell[0]) {
        case '0':
            pos[0] = 'T';
            pos[1] = 'T';
            break;
        case '1':
            phase = rnd_pcg_range(&forrng->rng,0,1);
            pos[phase]   = 'A';
            pos[1-phase] = 'T';
            break;
        case '2':
            pos[0] = 'A';
            pos[1] = 'A';
            break;
        }
        break;
    case GSC_GENOTYPECELLSTYLE_ENCODED:
        switch (cell[0]) {
        case 'G': // G
            pos[0] = 'G';
            pos[1] = 'G';
            break;
        case 'A': // A
            pos[0] = 'A';
            pos[1] = 'A';
            break;
        case 'T': // T
            pos[0] = 'T';
            pos[1] = 'T';
            break;
        case 'C': // C
            pos[0] = 'C';
            pos[1] = 'C';
            break;
        case 'R': // G/A
            phase = rnd_pcg_range(&forrng->rng,0,1);
            pos[phase]   = 'G';
            pos[1-phase] = 'A';
            break;
        case 'Y': // T/C
            phase = rnd_pcg_range(&forrng->rng,0,1);
            pos[phase]   = 'T';
            pos[1-phase] = 'C';
            break;
        case 'M': // A/C
            phase = rnd_pcg_range(&forrng->rng,0,1);
            pos[phase]   = 'A';
            pos[1-phase] = 'C';
            break;
        case 'K': // G/T
            phase = rnd_pcg_range(&forrng->rng,0,1);
            pos[phase]   = 'G';
            pos[1-phase] = 'T';
            break;
        case 'S': // G/C
            phase = rnd_pcg_range(&forrng->rng,0,1);
            pos[phase]   = 'G';
            pos[1-phase] = 'C';
            break;
        case 'W': // A/T
            phase = rnd_pcg_range(&forrng->rng,0,1);
            pos[phase]   = 'A';
            pos[1-phase] = 'T';
            break;
        default:
            break;
        }
        break;
    default: break;
    }
}
 
static struct gsc_EmptyListNavigator gsc_create_emptylistnavigator(gsc_SimData* d, 
                                                                   gsc_GroupNum allocation_group) {
    struct gsc_EmptyListNavigator me = { .d=d, 
                                         .localPos = 0, 
                                         .alloctogroup = allocation_group, 
                                         .currentid = d->current_id };
    me.firstAM = gsc_create_empty_allelematrix(me.d->genome.n_markers, 
                                               me.d->n_labels, 
                                               me.d->label_defaults, 0);
    me.localAM = me.firstAM;
    return me;
}
 
static gsc_GenoLocation gsc_emptylistnavigator_get_first(struct gsc_EmptyListNavigator* it) {
    it->localAM = it->firstAM;
    it->localPos = 0;
    if (1 > it->localAM->n_genotypes) {
        it->localAM->n_genotypes = 1;
        it->localAM->alleles[0] = gsc_malloc_wrap(sizeof(char) * (it->localAM->n_markers<<1),GSC_TRUE);
        memset(it->localAM->alleles[0], 0, sizeof(char) * (it->localAM->n_markers<<1));
        it->localAM->names[0] = NULL;
        it->localAM->groups[0] = it->alloctogroup;
        ++(it->currentid.id);
        it->localAM->ids[0] = it->currentid;
    }
    return (gsc_GenoLocation){.localAM=it->localAM, .localPos =it->localPos};
}
 
static gsc_GenoLocation gsc_emptylistnavigator_get_next(struct gsc_EmptyListNavigator* it) {
    if (CONTIG_WIDTH - 1 == it->localPos) {
        if (NULL == it->localAM->next) {
            gsc_AlleleMatrix* next = gsc_create_empty_allelematrix(it->d->genome.n_markers, 
                                                                   it->d->n_labels, 
                                                                   it->d->label_defaults, 0);
            it->localAM->next = next;
            it->localAM = next;
            it->localPos = 0;
        } else {
            it->localAM = it->localAM->next;
            it->localPos = 0;
        }
    } else {
        ++(it->localPos);
    }
 
    if (it->localAM->n_genotypes <= it->localPos) {
        if (1 < it->localPos - it->localAM->n_genotypes) {
            fprintf(stderr,"EmptyListNavigator invalid\n");
            return INVALID_GENO_LOCATION;
        }
        ++(it->localAM->n_genotypes);
 
        it->localAM->alleles[it->localPos] = gsc_malloc_wrap(sizeof(char) * (it->localAM->n_markers<<1),GSC_TRUE);
        memset(it->localAM->alleles[it->localPos], 0, sizeof(char) * (it->localAM->n_markers<<1));
        it->localAM->names[it->localPos] = NULL;
        it->localAM->groups[it->localPos] = it->alloctogroup;
        ++(it->currentid.id);
        it->localAM->ids[it->localPos] = it->currentid;
    }
 
    return (gsc_GenoLocation){.localAM=it->localAM, .localPos =it->localPos};
}
 
static void gsc_emptylistnavigator_finaliselist(struct gsc_EmptyListNavigator* it) {
    if (NULL == it->d->m) {
        it->d->m = it->firstAM;
    } else {
        gsc_AlleleMatrix* listend = it->d->m;
        while (NULL != listend->next) {
            listend = listend->next;
        }
        listend->next = it->firstAM;
        gsc_condense_allele_matrix(it->d);
    }
    it->d->current_id = it->currentid;
}
 
static struct gsc_GenotypeFile_MatrixFormat gsc_helper_genotypefile_matrix_detect_orientation(
                                                    const SimData* d, 
                                                    const gsc_TableFileCell* cellqueue, 
                                                    const size_t firstrowlen, 
                                                    const size_t queuelen,
                                                    struct gsc_GenotypeFile_MatrixFormat format, 
                                                    const char* filenameforlog) {
            
    if (format.markers_as_rows == GSC_TRUE || format.markers_as_rows == GSC_FALSE) {
        // pass
    } else if (d->genome.n_maps == 0) {
        // If there is no genetic map, we cannot check the row/column headers to see if any of them match the marker names..
        // Default to markers being rows
 
        printf("(Loading %s) Format axis: genetic markers are -rows-, founder lines are |columns| (by assumption when no genetic map is loaded)\n", filenameforlog);
        printf("(Loading %s) No genetic map is loaded, will invent a map where all markers are unlinked/show independent assortment\n", filenameforlog);
        format.markers_as_rows = GSC_TRUE;
 
    } else if (format.has_header == GSC_FALSE) {
        printf("(Loading %s) Format axis: genetic markers are -rows-, founder lines are |columns| "
                "(by assumption when matrix has no header row)\n", filenameforlog);
        format.markers_as_rows = GSC_TRUE;
 
    } else {
        // Note: by here, either the user has told us there is a header row, or we get to detect whether there is one. So will investigate it by comparing names to what's in our map
        // taken from older function gsc_helper_genotypefile_matrix_check_markers_are_rows
        int firstsafeheaderindex = -1;
        if (firstrowlen > 1) {
            firstsafeheaderindex = 1;
        } else if (firstrowlen == 1 && queuelen > firstrowlen + 1) { // second row has more than one cell read.
            firstsafeheaderindex = 0; // assume there's no corner cell
            format.has_header = GSC_TRUE;
        }
 
        if (firstsafeheaderindex >= 0) {
            // Don't check the "first" cell. It might be a corner cell between the two headers, whose value should be ignored
            // Check the next cell in the first row.
            if (gsc_get_index_of_genetic_marker(cellqueue[firstsafeheaderindex].cell, d->genome, NULL)) {
                printf("(Loading %s) Format axis: genetic markers are |columns|, founder lines are -rows-\n", filenameforlog);
                format.markers_as_rows = GSC_FALSE;
                format.has_header = GSC_TRUE;
                return format;
            }
 
            // If that wasn't a match, check the first row header, if it exists:
            if (queuelen > firstrowlen && !cellqueue[firstrowlen].eof &&
                    gsc_get_index_of_genetic_marker(cellqueue[firstrowlen].cell, d->genome, NULL)) {
                printf("(Loading %s) Format axis: genetic markers are -rows-, founder lines are |columns|\n", filenameforlog);
                format.markers_as_rows = GSC_TRUE;
                return format;
            }
 
            // Check remaining column headers
            for (size_t i = firstsafeheaderindex + 1; i < firstrowlen; ++i) {
                if (gsc_get_index_of_genetic_marker(cellqueue[i].cell, d->genome, NULL)) {
                    printf("(Loading %s) Format axis: genetic markers are |columns|, founder lines are -rows-\n", filenameforlog);
                    format.markers_as_rows = GSC_FALSE;
                    format.has_header = GSC_TRUE;
                    return format;
                }
            }
 
        }
        printf("(Loading %s) Format axis: genetic markers are -rows-, founder lines are |columns| (by default file format)\n", filenameforlog);
        format.markers_as_rows = GSC_TRUE;
    }
    return format;
 
}
 
static struct gsc_GenotypeFile_MatrixFormat gsc_helper_genotypefile_matrix_detect_cellstyle(
                                                                const gsc_TableFileCell* cellqueue, 
                                                                const size_t firstrowlen, 
                                                                const size_t queuelen, 
                                                                struct gsc_GenotypeFile_MatrixFormat format, 
                                                                const char* filenameforlog) {
 
    _Bool style_detected = 0;
    _Bool single_col_file = 0;
    // 1. Detect format if not yet provided.
    if (format.cell_style == GSC_GENOTYPECELLSTYLE_UNKNOWN) {
        style_detected = 1;
 
        if (firstrowlen == queuelen || cellqueue[firstrowlen].eof) { // There is only one row. Short-circuiting necessary
            // if there is also only one column, we have no body cells to detect the style of
            if (firstrowlen > 1) {
                // Detection path for a single-line file. If it has a header, then this value might end up ignored
                format.cell_style = gsc_helper_genotype_matrix_identify_cell_style(cellqueue[1]);
            } else {
                single_col_file = 1; // one-cell file. needs the warning.
            }
        } else { // there is more than one row
            // If there is only one column, there are no body cells with style to detect
            if (firstrowlen + 1 < queuelen && cellqueue[firstrowlen+1].predNewline < 1) {
                // Detection path. There exists a second cell on the second line that we can read
                format.cell_style = gsc_helper_genotype_matrix_identify_cell_style(cellqueue[firstrowlen+1]);
            } else {
                single_col_file = 1;
            }
        }
    }
    
    // 2. Print cell style detection logs 
    if (style_detected) {
        switch(format.cell_style) {
            case GSC_GENOTYPECELLSTYLE_PAIR:      printf("(Loading %s) Allele format: phased allele pairs\n", filenameforlog); break;
            case GSC_GENOTYPECELLSTYLE_SLASHPAIR: printf("(Loading %s) Allele format: phased allele pairs (slash-separated)\n", filenameforlog); break;
            case GSC_GENOTYPECELLSTYLE_COUNT:     printf("(Loading %s) Allele format: reference allele counts (phase will be randomised)\n", filenameforlog); break;
            case GSC_GENOTYPECELLSTYLE_ENCODED:   printf("(Loading %s) Allele format: IUPAC encoded pair (phase will be randomised)\n", filenameforlog); break;
            case GSC_GENOTYPECELLSTYLE_UNKNOWN:
                if (single_col_file || firstrowlen == queuelen ||
                        (firstrowlen + 1 == queuelen && cellqueue[firstrowlen].eof && cellqueue[firstrowlen].cell_len == 0)) {
                    printf("(Loading %s) Warning: empty genotype matrix. No genotypes will be loaded.\n", filenameforlog);
                } else {
                    fprintf(stderr,"(Loading %s) Failure: Unable to determine the formatting of pairs of alleles."
                    " Check genomicSimulation manual for accepted allele pair encodings\n", filenameforlog);
                }
        }
    }
    
    return format;
}
 
static struct gsc_GenotypeFile_MatrixFormat gsc_helper_genotypefile_matrix_detect_header(
                                                            const gsc_TableFileCell* cellqueue, 
                                                            const size_t firstrowlen, 
                                                            const size_t queuelen, 
                                                            struct gsc_GenotypeFile_MatrixFormat format, 
                                                            const char* filenameforlog) {
    // Validity check: if genetic markers are columns, header row is mandatory
    if (format.has_header == GSC_FALSE && format.markers_as_rows == GSC_FALSE) {
        printf("(Loading %s) Failure: genetic markers cannot be represented by columns when matrix has no header row\n", filenameforlog);
        format.has_header = GSC_NA;
        return format;
    }
 
    // Detect header if we need to detect it.
    if (format.has_header != GSC_FALSE && format.has_header != GSC_TRUE) {
        if (firstrowlen == 1) { 
            // we could have a single-column file (no header assumed), or 
            // we could be a two-column file with no corner cell (must have a header)
            if (queuelen > 2) {
                if (cellqueue[2].eof || cellqueue[2].predNewline) {
                    format.has_header = GSC_FALSE; // single column file
                } else {
                    format.has_header = GSC_TRUE; 
                }
            } // else can't draw any conclusions.
            
        } else if (format.cell_style != GSC_GENOTYPECELLSTYLE_UNKNOWN) {
            // Idea: if we find a cell in the first row that doesn't match the expected cell style, then that first row is probably a header
            format.has_header = GSC_FALSE;
            for (size_t i = 1; i < firstrowlen; ++i) { // ignore first cell in row, it could be a corner cell or row header
                if (gsc_helper_genotype_matrix_identify_cell_style(cellqueue[i]) != format.cell_style) {
                    format.has_header = GSC_TRUE;
                    break;
                }
            }
        } // else don't know how to detect.
 
        switch (format.has_header) {
            case GSC_FALSE: printf("(Loading %s) Format: genotype matrix without header row\n", filenameforlog); break;
            case GSC_TRUE: printf("(Loading %s) Format: genotype matrix with header row\n", filenameforlog); break;
            default: fprintf(stderr,"(Loading %s) Failure: Unable to determine whether file has header row\n", filenameforlog); break;
        }
    }
 
    return format;
}
 
static GSC_LOGICVAL gsc_helper_genotypefile_matrix_detect_cornercell_presence(
                                                            const size_t ncellsfirstrow, 
                                                            const size_t ncellssecondrow, 
                                                            const _Bool secondrowheaderisempty) {
    if (ncellssecondrow == ncellsfirstrow + 1) {
        return GSC_FALSE;
    } else if (ncellssecondrow == ncellsfirstrow) {
        if (secondrowheaderisempty) {
            return GSC_FALSE; //genotype name is simply empty, making the second row look one column shorter than reality
        } else {
            return GSC_TRUE;
        }
    } else if (ncellssecondrow == ncellsfirstrow - 1 && secondrowheaderisempty) {
        return GSC_TRUE; // genotype name on row 2 is empty but corner cell is not
    } else {
        return GSC_NA;
    }
}
 
gsc_FileFormatSpec gsc_define_matrix_format_details(const GSC_LOGICVAL has_header, 
                                                    const GSC_LOGICVAL markers_as_rows, 
                                                    const enum gsc_GenotypeFileCellStyle cell_style) {
    return (FileFormatSpec){.filetype=GSC_GENOTYPEFILE_MATRIX,
                            .spec={(struct gsc_GenotypeFile_MatrixFormat){.cell_style=cell_style,
                                                                        .has_header=has_header,
                                                                        .markers_as_rows=markers_as_rows}}};
}
 
static gsc_GroupNum gsc_load_genotypefile_matrix(gsc_SimData* d, 
                                                 const char* filename, 
                                                 const gsc_FileFormatSpec format) {
    if (filename == NULL) return NO_GROUP;
    if (format.filetype != GSC_GENOTYPEFILE_MATRIX && format.filetype != GSC_GENOTYPEFILE_UNKNOWN) {
        fprintf(stderr,"Non-genotype-matrix format specification provided to genotype matrix file loader function\n");
        return NO_GROUP;
    }
 
    // Part 1: Detect file formatting details
    struct gsc_GenotypeFile_MatrixFormat format_detected = 
        { .has_header = GSC_NA, .markers_as_rows = GSC_NA, .cell_style = GSC_GENOTYPECELLSTYLE_UNKNOWN };
    if (format.filetype == GSC_GENOTYPEFILE_MATRIX) {
        format_detected = format.spec.matrix;
    }
    size_t queuesize = 0;
 
    gsc_TableFileReader tbl = gsc_tablefilereader_create(filename);
    if (tbl.fp == NULL) { return NO_GROUP; }
    // Read one row + 2 cells (if possible)
    GSC_CREATE_BUFFER(cellsread,gsc_TableFileCell,100);
    size_t ncellsread = 0;
    do {
        cellsread[ncellsread] = gsc_tablefilereader_get_next_cell(&tbl);
        gsc_tablefilecell_deep_copy(&cellsread[ncellsread]);
        ++ncellsread;
        if (ncellsread >= cellsreadcap) {
            GSC_STRETCH_BUFFER(cellsread,2*ncellsread);
        }
    } while (!cellsread[ncellsread-1].eof && (ncellsread <= 1 || !cellsread[ncellsread-1].predNewline));
    size_t ncellsfirstrow = (cellsread[ncellsread-1].eof && cellsread[ncellsread-1].cell_len > 0) ? ncellsread : ncellsread - 1;
    if (!cellsread[ncellsread-1].eof) { // read one more cell if possible
        cellsread[ncellsread] = gsc_tablefilereader_get_next_cell(&tbl);
        gsc_tablefilecell_deep_copy(&cellsread[ncellsread]);
        ++ncellsread;
        if (ncellsread >= cellsreadcap) {
            GSC_STRETCH_BUFFER(cellsread,2*ncellsread);
        }
    }
    queuesize = ncellsread; // so that we know how many to free if we failure_exit
    if (ncellsread <= 1) { // file is an EOF only
        goto failure_exit;
    }
    //int is_onecol_file = cellsread[ncellsfirstrow + 1].predNewline > 0 || ncellsread == 2; // ncellsread == 2 means we read one cell, then an EOF
    int is_onerow_file = ncellsread == ncellsfirstrow || cellsread[ncellsfirstrow].eof; // short-circuiting essential!
 
    format_detected = gsc_helper_genotypefile_matrix_detect_orientation(d, cellsread, ncellsfirstrow, ncellsread, format_detected, filename);
    format_detected = gsc_helper_genotypefile_matrix_detect_cellstyle(cellsread, ncellsfirstrow, ncellsread, format_detected, filename);
    format_detected = gsc_helper_genotypefile_matrix_detect_header(cellsread, ncellsfirstrow, ncellsread, format_detected, filename);
    if ((format_detected.has_header != GSC_FALSE && format_detected.has_header != GSC_TRUE) || 
        (format_detected.markers_as_rows != GSC_FALSE && format_detected.markers_as_rows != GSC_TRUE) ||
        format_detected.cell_style == GSC_GENOTYPECELLSTYLE_UNKNOWN) {
            goto failure_exit;
    }
 
    GSC_LOGICVAL format_has_corner_cell = GSC_NA;
    // If markers as columns, we do need to know how many cells are in the second row in order to detect a corner cell
    if (!format_detected.markers_as_rows && !is_onerow_file) {
        // Read rest of second row
        while (!cellsread[ncellsread-1].eof && !cellsread[ncellsread-1].predNewline) {
            cellsread[ncellsread] = gsc_tablefilereader_get_next_cell(&tbl);
            gsc_tablefilecell_deep_copy(&cellsread[ncellsread]);
            ++ncellsread;
            if (ncellsread >= cellsreadcap) {
                GSC_STRETCH_BUFFER(cellsread,2*ncellsread);
            }
        }
        // Detect corner cell
        queuesize = ncellsread; // so that we know how many to free if we failure_exit
        size_t ncellssecondrow = ncellsread - ncellsfirstrow - 1;
        format_has_corner_cell = gsc_helper_genotypefile_matrix_detect_cornercell_presence(ncellsfirstrow, ncellssecondrow, cellsread[ncellsfirstrow].predCol > 0);
        if (format_has_corner_cell == GSC_NA) {
            fprintf(stderr, "(Loading %s) Failure: Header row length and second row length do not align\n", filename);
            goto failure_exit;
        }
    }
 
    // Create the queue of cells to parse (exclude header from this queue, because it needs to be dealt with differently)
    gsc_TableFileCell* cellqueue = cellsread;
    //queuesize = ncellsread; (already done above)
    if (format_detected.has_header) {
        cellqueue = cellsread + ncellsfirstrow;
        queuesize = ncellsread - ncellsfirstrow;
    }
 
    // PART 2: Create uniform-spaced map, if we have no map currently
    _Bool build_map_from_rows = 0;
    if (d->genome.n_markers == 0) {
        if (format_detected.markers_as_rows) {
            build_map_from_rows = 1;
            // We're going to have to do an independent read of the file to extract these. Will be a bit slower.
            gsc_TableFileReader tbl2 = gsc_tablefilereader_create(filename);
            gsc_TableFileCell cell = gsc_tablefilereader_get_next_cell(&tbl2);
            GSC_GENOLEN_T nmarkersread = format_detected.has_header ? 0 : 1;
            do {
             cell = gsc_tablefilereader_get_next_cell(&tbl2);
                if (cell.predNewline) { ++nmarkersread; }
                if (!cell.isCellShallow) { GSC_FREE(cell.cell); }
            } while (!cell.eof);
            gsc_tablefilereader_close(&tbl2);
            if (cell.predNewline) { // there's a newline before eof, so no real actual last row
                --nmarkersread;
            }
 
            d->genome.n_markers = nmarkersread;
            d->genome.marker_names = gsc_malloc_wrap(sizeof(*d->genome.marker_names)*d->genome.n_markers, GSC_TRUE);
            d->genome.names_alphabetical = gsc_malloc_wrap(sizeof(*d->genome.names_alphabetical)*d->genome.n_markers, GSC_TRUE);
            gsc_create_unlinked_recombmap(d,0,NULL); // create based on the markers we've saved in 'genome'
            
        } else { // markers as columns
            if (!format_detected.has_header) { // you should not be able to get here. // assert(format_detected.has_header == GSC_TRUE);
                fprintf(stderr, "(Loading %s) Failure: Genotype matrix with markers as columns but no header row is an unsupported file type (there is no way to tell which column is which marker)\n", filename);
                goto failure_exit;
            }
            
            size_t i = format_has_corner_cell ? 1 : 0; // starting index for iterating through names
            d->genome.n_markers = ncellsfirstrow - i;
            d->genome.marker_names = gsc_malloc_wrap(sizeof(*d->genome.marker_names)*d->genome.n_markers, GSC_TRUE);
            d->genome.names_alphabetical = gsc_malloc_wrap(sizeof(*d->genome.names_alphabetical)*d->genome.n_markers, GSC_TRUE);
            for (size_t j = 0; j < d->genome.n_markers; ++i, ++j) {
                //gsc_tablefilecell_deep_copy(&cellqueue[i]); // already deep copied
                d->genome.marker_names[j] = cellsread[i].cell;
                cellsread[i].isCellShallow = GSC_TRUE; // prevent deletion
                d->genome.names_alphabetical[j] = &d->genome.marker_names[j];
            }
            qsort(d->genome.names_alphabetical,d->genome.n_markers,sizeof(*d->genome.names_alphabetical),gsc_helper_indirect_alphabetical_str_comparer);
            gsc_create_unlinked_recombmap(d,0,NULL); // create based on the markers we've saved in 'genome'
        }
    }
 
    // PART 3: Parse file into an AlleleMatrix
    
    gsc_GroupNum group = gsc_get_new_group_num(d);
    struct gsc_EmptyListNavigator it = gsc_create_emptylistnavigator(d, group);
    GSC_GENOLEN_T nvalidmarker = 0;
    size_t n_cols = 0;
    if (format_detected.markers_as_rows) {
 
        gsc_GenoLocation loc;
        gsc_TableFileCell ncell;
        n_cols = (format_detected.has_header) ? ncellsfirstrow + 1 : ncellsfirstrow; // assume first row has no corner cell for now
        _Bool first = 1; 
        _Bool have_valid_marker = 0; GSC_GENOLEN_T markerix;
        GSC_GLOBALX_T column = 0;
        size_t row = 0;
        do {
            ncell = gsc_helper_tablefilereader_get_next_cell_wqueue(&tbl,&cellqueue,&queuesize);
 
            if (ncell.cell != NULL) {
                if (ncell.predNewline || first) {
                    
                    
                    if (build_map_from_rows) {
                        ++nvalidmarker; have_valid_marker = 1;
                        if (first) {
                            markerix = 0;
                        } else {
                            markerix++;
                        }
                        gsc_tablefilecell_deep_copy(&ncell);
                        d->genome.marker_names[markerix] = ncell.cell;
                        ncell.cell = NULL; // prevent deletion
                    } else {
                        char tmp = ncell.cell[ncell.cell_len]; ncell.cell[ncell.cell_len] = '\0';
                        
                        have_valid_marker = gsc_get_index_of_genetic_marker(ncell.cell, d->genome, &markerix);
                        
                        nvalidmarker += have_valid_marker;
                        ncell.cell[ncell.cell_len] = tmp;
                    }
                    
                    
                    // Then, after reading first row, detect what our expected row length is, if defaults don't suit.
                    if (row == 1 && format_detected.has_header) { 
                        if (column + 1 != ncellsfirstrow && column + 1 != ncellsfirstrow + 1) {
                            fprintf(stderr, "(Loading %s) Failure: Header row length and second row length do not align\n", filename);
                            goto failure_exit;
                        } else {
                            n_cols = column + 1;
                        }
                    }
                    first = 0;
                    column = 0;
                    ++row;
 
                } else if (ncell.predCol) { // any number of column spacers treated as one column gap when reading a genotype matrix
                    ++column;
                    if (have_valid_marker && column < n_cols) {
                        loc = (1 == column) ? gsc_emptylistnavigator_get_first(&it) : gsc_emptylistnavigator_get_next(&it);
                        gsc_helper_genotypecell_to_allelematrix(loc,markerix,format_detected.cell_style,ncell.cell,d);
                    } // Note we ignore all extra cells in all rows
                }
            }
 
            if (!ncell.isCellShallow) { GSC_FREE(ncell.cell); }
        } while (!ncell.eof);
        if (row == 1 && format_detected.has_header) {
            if (column + 1 != ncellsfirstrow && column + 1 != ncellsfirstrow + 1) {
                fprintf(stderr, "(Loading %s) Failure: Header row length and second row length do not align\n", filename);
                goto failure_exit;
            } else {
                n_cols = column + 1;
            }
        }
 
        // Then save the genotype names
        if (format_detected.has_header) {
            format_has_corner_cell = gsc_helper_genotypefile_matrix_detect_cornercell_presence(ncellsfirstrow, n_cols, cellsread[ncellsfirstrow].predCol > 0);
            size_t i = format_has_corner_cell ? 1 : 0;
            gsc_GenoLocation loc;
            for (size_t j = 0; i < ncellsfirstrow; ++i, ++j) {
                loc = (j == 0) ? gsc_emptylistnavigator_get_first(&it) : gsc_emptylistnavigator_get_next(&it);
                // assert(!cellsread[i].isShallowCopy);
                gsc_set_name(loc,cellsread[i].cell); // using names here so no need to free them. Since they're in cellsread 
                cellsread[i].isCellShallow = GSC_TRUE; // prevent deletion
            }
        }
 
        // Then finalise the map, if we're creating one:
        if (build_map_from_rows) {
            for (GSC_GENOLEN_T i = 0; i < d->genome.n_markers; ++i) {
                d->genome.names_alphabetical[i] = &d->genome.marker_names[i];
            }
            qsort(d->genome.names_alphabetical,d->genome.n_markers,sizeof(*d->genome.names_alphabetical),gsc_helper_indirect_alphabetical_str_comparer);
        }
        
    } else { // markers as columns
        if (!format_detected.has_header) { // you should not be able to get here.
            fprintf(stderr, "(Loading %s) Failure: Genotype matrix with markers as columns but no header row is an unsupported file type (there is no way to tell which column is which marker)\n", filename);
            goto failure_exit;
        }
 
        // Identify the marker corresponding to each column
        size_t i = format_has_corner_cell ? 1 : 0;
        size_t n_col = ncellsfirstrow + (1-i);
        GSC_GENOLEN_T* markerixs = gsc_malloc_wrap(sizeof(*markerixs)*ncellsfirstrow,GSC_TRUE);
        for (GSC_GENOLEN_T j = 0; i < ncellsfirstrow; ++i, ++j) {
            markerixs[j] = d->genome.n_markers;
            nvalidmarker += gsc_get_index_of_genetic_marker(cellsread[i].cell, d->genome, &markerixs[j]);
        }
 
        // Read the table
        _Bool first = 1; 
        GSC_GLOBALX_T row = 0;
        size_t column = 0; // we count column numbers from 1 for the first body cell. sorry for the inconsistency with the branch of the if statement above.
        gsc_GenoLocation loc = gsc_emptylistnavigator_get_first(&it);
        gsc_TableFileCell ncell;
        do {
            ncell = gsc_helper_tablefilereader_get_next_cell_wqueue(&tbl,&cellqueue,&queuesize);
 
            if (ncell.cell != NULL) {
                if (ncell.predNewline) {
                    loc = (first) ? gsc_emptylistnavigator_get_first(&it) : gsc_emptylistnavigator_get_next(&it);
                    first = 0;
                    
                    ++row;
                    column = 0;
                    if (ncell.predCol) { // missing name.
                        gsc_set_name(loc,NULL);
                    } else {
                        gsc_tablefilecell_deep_copy(&ncell);
                        gsc_set_name(loc,ncell.cell);
                        ncell.isCellShallow = GSC_TRUE; // so it does not get deleted
                    }
                }
 
                if (ncell.predCol) {
                    ++column;
                    if (column < n_col && markerixs[column-1] < d->genome.n_markers) {
                        gsc_helper_genotypecell_to_allelematrix(loc,markerixs[column-1],format_detected.cell_style,ncell.cell,d);
                    }
                }
            }
 
            if (!ncell.isCellShallow) { GSC_FREE(ncell.cell); } 
        } while (!ncell.eof);
 
        GSC_FREE(markerixs);
        
    }
 
    // PART 4: Tidy and clean and exit
    GSC_GLOBALX_T ngenos = 0;
    AlleleMatrix* tmpam = it.firstAM;
    while (tmpam != NULL) {
        ngenos += tmpam->n_genotypes;
        tmpam = tmpam->next;
    }
    printf("(Loading %s) %lu genotype(s) of %lu marker(s) were loaded.\n", filename, 
            (long unsigned int) ngenos, (long unsigned int) nvalidmarker);
    if (ngenos == 0) {
        gsc_delete_allele_matrix(it.firstAM);
        goto failure_exit;
    }
    gsc_emptylistnavigator_finaliselist(&it);
    ++d->n_groups;
 
    // ... cleaning up the header row
    if (format_detected.has_header) {
        for (size_t j = 0; j < ncellsfirstrow; ++j) { 
            if (!cellsread[j].isCellShallow) { GSC_FREE(cellsread[j].cell); }
        }
    }
    GSC_DELETE_BUFFER(cellsread);
    gsc_tablefilereader_close(&tbl);
    return group;
 
    failure_exit:
        // Clean up structures and return, having loaded no genotypes
        // ... cleaning up unprocessed cells in the queue
        for (size_t i = 1; i <= queuesize; ++i) { 
            if (!cellsread[ncellsread-i].isCellShallow) {
                GSC_FREE(cellsread[ncellsread-i].cell); 
                cellsread[ncellsread-i].isCellShallow = GSC_TRUE;
            }
        }
        // ... cleaning up the header row
        if (format_detected.has_header) {
            for (size_t j = 0; j < ncellsfirstrow; ++j) { 
                if (!cellsread[j].isCellShallow) { GSC_FREE(cellsread[j].cell); }
            }
        }
        GSC_DELETE_BUFFER(cellsread);
        gsc_tablefilereader_close(&tbl);
        return NO_GROUP;
}
 
gsc_GroupNum gsc_load_genotypefile(SimData* d, 
                                   const char* filename, 
                                   const gsc_FileFormatSpec format) {
    return gsc_load_data_files(d,filename,NULL,NULL,format).group;
}
 
struct gsc_MultiIDSet gsc_load_data_files(gsc_SimData* d, 
                                          const char* genotype_file,
                                          const char* map_file, 
                                          const char* effect_file, 
                                          const gsc_FileFormatSpec format) {
    // Parse file suffix for file type, if it was not already provided
    enum gsc_GenotypeFileType type = format.filetype;
 
    if (type == GSC_GENOTYPEFILE_UNKNOWN && genotype_file != NULL) {
        type = GSC_GENOTYPEFILE_MATRIX;
        char* suffix = strrchr(genotype_file,'.');
        if (suffix != NULL) {
            if (strcmp(suffix,".bed") == 0) {
                type = GSC_GENOTYPEFILE_BED;
            } else if (strcmp(suffix,".ped") == 0) {
                type = GSC_GENOTYPEFILE_PED;
            } else if (strcmp(suffix,".vcf") == 0) {
                type = GSC_GENOTYPEFILE_VCF;
            }
        }
    }
 
    struct gsc_MultiIDSet out = { .group=NO_GROUP, .map=NO_MAP, .effSet=NO_EFFECTSET };
 
    switch (type) {
    case GSC_GENOTYPEFILE_BED:
        //if (detectedtype) { printf("Will attempt to parse %s as a plink .bed file\n", filename); }
        fprintf(stderr,"plink .bed file parsing not yet implemented\n");
        break;
    case GSC_GENOTYPEFILE_PED:
        fprintf(stderr,"plink .ped file parsing not yet implemented\n");
        break;
    case GSC_GENOTYPEFILE_VCF:
        fprintf(stderr,"vcf file parsing not yet implemented\n");
        break;
    default:
        //printf("(Loading files) Will treat %s as a genotype matrix (see genomicSimulation's default input file types)\n", genotype_file);
        out.map = gsc_load_mapfile(d, map_file);
        out.group = gsc_load_genotypefile_matrix(d, genotype_file, format);
        out.effSet = gsc_load_effectfile(d, effect_file);
    }
 
    return out;
}
 
/*--------------------------Recombination counts-----------------------------*/
 
int* gsc_calculate_min_recombinations_fw1(gsc_SimData* d, gsc_MapID mapid, char* parent1, unsigned int p1num, char* parent2,
        unsigned int p2num, char* offspring, int certain) {
    if (d->genome.n_maps < 1) {
        fprintf(stderr,"Need at least one recombination map loaded to estimate recombinations\n");
        return NULL;
    }
    int mapix = 0;
    if (mapid.id != NO_MAP.id) { mapix = gsc_get_index_of_map(d, mapid); }
    if (mapix >= d->genome.n_maps) {
        fprintf(stderr,"We don't have that recombination maps loaded\n");
        return NULL;
    }
    gsc_RecombinationMap map = d->genome.maps[mapix];
 
    int* origins = gsc_malloc_wrap(sizeof(int) * d->genome.n_markers,GSC_TRUE);
    memset(origins,0,sizeof(*origins)*d->genome.n_markers);
    int p1match, p2match;
    int previous = 0;
 
 
    for (int chr = 0; chr < map.n_chr; ++chr) {
        //RPACKINSERT R_CheckUserInterrupt();
 
        switch (map.chrs[chr].type) {
        case GSC_LINKAGEGROUP_SIMPLE:
            for (int i = 0; i < map.chrs[chr].map.simple.n_markers; ++i) {
                p1match = gsc_has_same_alleles(parent1, offspring, i);
                p2match = gsc_has_same_alleles(parent2, offspring, i);
                if (p1match && !p2match) {
                    origins[map.chrs[chr].map.simple.first_marker_index + i] = p1num;
                    previous = p1num;
                } else if (p2match && !p1match) {
                    origins[map.chrs[chr].map.simple.first_marker_index + i] = p2num;
                    previous = p2num;
                } else {
                    if (certain) {
                        origins[map.chrs[chr].map.simple.first_marker_index + i] = 0;
                    } else {
                        origins[map.chrs[chr].map.simple.first_marker_index + i] = previous;
                    }
                }
            }
            break;
 
        case GSC_LINKAGEGROUP_REORDER:
            for (int i = 0; i < map.chrs[chr].map.reorder.n_markers; ++i) {
                p1match = gsc_has_same_alleles(parent1, offspring, i);
                p2match = gsc_has_same_alleles(parent2, offspring, i);
                if (p1match && !p2match) {
                    origins[map.chrs[chr].map.reorder.marker_indexes[i]] = p1num;
                    previous = p1num;
                } else if (p2match && !p1match) {
                    origins[map.chrs[chr].map.reorder.marker_indexes[i]] = p2num;
                    previous = p2num;
                } else {
                    if (certain) {
                        origins[map.chrs[chr].map.reorder.marker_indexes[i]] = 0;
                    } else {
                        origins[map.chrs[chr].map.reorder.marker_indexes[i]] = previous;
                    }
                }
            }
            break;
        }
 
    }
    return origins;
}
 
int* gsc_calculate_min_recombinations_fwn(gsc_SimData* d, gsc_MapID mapid, char* parent1, unsigned int p1num, char* parent2,
        unsigned int p2num, char* offspring, int window_size, int certain) {
    if (d->genome.n_maps < 1) {
        fprintf(stderr,"Need at least one recombination map loaded to estimate recombinations\n");
        return NULL;
    }
    int mapix = 0;
    if (mapid.id != NO_MAP.id) { mapix = gsc_get_index_of_map(d, mapid); }
    if (mapix >= d->genome.n_maps) {
        fprintf(stderr,"We don't have that recombination maps loaded\n");
        return NULL;
    }
    gsc_RecombinationMap map = d->genome.maps[mapix];
 
 
    int* origins = gsc_malloc_wrap(sizeof(int) * d->genome.n_markers,GSC_TRUE);
    memset(origins,0,sizeof(*origins)*d->genome.n_markers);
    int p1match, p2match;
    int previous = 0, window_range = (window_size - 1)/2, i;
 
    for (int chr = 0; chr < map.n_chr; ++chr) {
        //RPACKINSERT R_CheckUserInterrupt();
 
        switch (map.chrs[chr].type) {
        case GSC_LINKAGEGROUP_SIMPLE:
            for (i = 0; i < window_range; ++i) {
                origins[map.chrs[chr].map.simple.first_marker_index + i] = 0;
            }
            for (; i < map.chrs[chr].map.simple.n_markers - window_range; ++i) {
                p1match = gsc_has_same_alleles_window(parent1, offspring, i, window_size);
                p2match = gsc_has_same_alleles_window(parent2, offspring, i, window_size);
                if (p1match && !p2match) {
                    origins[map.chrs[chr].map.simple.first_marker_index + i] = p1num;
                    previous = p1num;
                } else if (p2match && !p1match) {
                    origins[map.chrs[chr].map.simple.first_marker_index + i] = p2num;
                    previous = p2num;
                } else {
                    if (certain) {
                        origins[map.chrs[chr].map.simple.first_marker_index + i] = 0;
                    } else {
                        origins[map.chrs[chr].map.simple.first_marker_index + i] = previous;
                    }
                }
            }
            for (; i < map.chrs[chr].map.simple.n_markers; ++i) {
                origins[map.chrs[chr].map.simple.first_marker_index + i] = 0;
            }
            break;
 
        case GSC_LINKAGEGROUP_REORDER:
            for (i = 0; i < window_range; ++i) {
                origins[map.chrs[chr].map.reorder.marker_indexes[i]] = 0;
            }
            for (; i < map.chrs[chr].map.reorder.n_markers - window_range; ++i) {
                p1match = gsc_has_same_alleles_window(parent1, offspring, i, window_size);
                p2match = gsc_has_same_alleles_window(parent2, offspring, i, window_size);
                if (p1match && !p2match) {
                    origins[map.chrs[chr].map.reorder.marker_indexes[i]] = p1num;
                    previous = p1num;
                } else if (p2match && !p1match) {
                    origins[map.chrs[chr].map.reorder.marker_indexes[i]] = p2num;
                    previous = p2num;
                } else {
                    if (certain) {
                        origins[map.chrs[chr].map.reorder.marker_indexes[i]] = 0;
                    } else {
                        origins[map.chrs[chr].map.reorder.marker_indexes[i]] = previous;
                    }
                }
            }
            for (; i < map.chrs[chr].map.reorder.n_markers; ++i) {
                origins[map.chrs[chr].map.reorder.marker_indexes[i]] = 0;
            }
            break;
        }
 
    }
    return origins;
}
 
int gsc_calculate_recombinations_from_file(gsc_SimData* d, const char* input_file, const char* output_file,
        int window_len, int certain) {
    struct gsc_TableSize t = gsc_get_file_dimensions(input_file, '\t');
    //open file
    FILE* fp;
    if ((fp = fopen(input_file, "r")) == NULL) {
        fprintf(stderr, "Failed to open file %s.\n", input_file); exit(1);
    }
    FILE* fpo;
    if ((fpo = fopen(output_file, "w")) == NULL) {
        fprintf(stderr, "Failed to open file %s.\n", output_file); exit(1);
    }
 
    // print header.
    for (int j = 0; j < d->genome.n_markers; ++j) {
        fprintf(fpo, "\t%s", d->genome.marker_names[j]);
    }
 
    int combin_i[3];
    char* combin_genes[3];
    char buffer[3][50];
    int* r;
    // for each row in file
    for (int i = 0; i < t.num_rows; ++i) {
        // load the four grandparents
        fscanf(fp, "%s %s %s \n", buffer[0], buffer[1], buffer[2]);
        combin_i[0] = gsc_get_index_of_name(d->m, buffer[0]);
        combin_i[1] = gsc_get_index_of_name(d->m, buffer[1]);
        combin_i[2] = gsc_get_index_of_name(d->m, buffer[2]);
        if (combin_i[0] < 0 || combin_i[1] < 0 || combin_i[2] < 0) {
            fprintf(stderr, "Genotypes at file %s line %lu could not be found\n", input_file, (long unsigned int) i);
            continue;
        }
        combin_genes[0] = gsc_get_genes_of_index(d->m, combin_i[0]);
        combin_genes[1] = gsc_get_genes_of_index(d->m, combin_i[1]);
        combin_genes[2] = gsc_get_genes_of_index(d->m, combin_i[2]);
 
        if (window_len == 1) {
            r = gsc_calculate_min_recombinations_fw1(d, NO_MAP, combin_genes[1],
                    gsc_get_id_of_index(d->m, combin_i[1]).id, combin_genes[2],
                    gsc_get_id_of_index(d->m, combin_i[2]).id, combin_genes[0], certain);
        } else {
            r = gsc_calculate_min_recombinations_fwn(d, NO_MAP, combin_genes[1],
                    gsc_get_id_of_index(d->m, combin_i[1]).id, combin_genes[2],
                    gsc_get_id_of_index(d->m, combin_i[2]).id, combin_genes[0], window_len, certain);
        }
        fprintf(fpo, "\n%s", buffer[0]);
        for (int j = 0; j < d->genome.n_markers; ++j) {
            fprintf(fpo, "\t%d", r[j]);
        }
        GSC_FREE(r);
    }
 
    fclose(fp);
    fwrite("\n", sizeof(char), 1, fpo);
    fflush(fpo);
    fclose(fpo);
    return 0;
}
 
 
/*--------------------------------Crossing-----------------------------------*/
 
void gsc_generate_gamete(gsc_SimData* d, 
                         const char* parent_genome, 
                         char* output, 
                         const GSC_ID_T map_index) {
    // assumes rand is already seeded
    if (parent_genome == NULL) {
        fprintf(stderr, "Could not generate this gamete: no parent provided\n");
        return;
    }
    if (map_index >= d->genome.n_maps) {
        fprintf(stderr, "Could not generate this gamete: invalid map provided\n");
        return;
    }
    gsc_RecombinationMap map = d->genome.maps[map_index];
 
    // treat each chromosome separately.
    GSC_CREATE_BUFFER(crossover_where, double, 100);
    for (GSC_GENOLEN_T chr = 0; chr < d->genome.maps[map_index].n_chr; ++chr) {
 
        // Task 1: How many crossovers
        int num_crossovers;
        switch (map.chrs[chr].type) {
            case GSC_LINKAGEGROUP_SIMPLE:
                num_crossovers = gsc_randpoi(&d->rng, map.chrs[chr].map.simple.expected_n_crossovers);
                break;
            case GSC_LINKAGEGROUP_REORDER:
                num_crossovers = gsc_randpoi(&d->rng, map.chrs[chr].map.reorder.expected_n_crossovers);
                break;
            default:
                fprintf(stderr, "Linkage group type of linkage group with index %lu of map with index %lu is corrupted\n", 
                        (long unsigned int) chr, (long unsigned int) map_index);
                num_crossovers = 0;
        }
 
        // Task 2: Find positions of all crossovers
        if (num_crossovers > crossover_wherecap) {
            GSC_STRETCH_BUFFER(crossover_where,num_crossovers);
        }
        for (int i = 0; i < num_crossovers; ++i) {
            crossover_where[i] = ((double)rand() / (double)RAND_MAX);
        }
        if (num_crossovers > 1) {
            qsort(crossover_where, num_crossovers, sizeof(double), gsc_helper_ascending_double_comparer);
        }
 
        // Task 3: Read off the gamete that those crossovers produce.
        int which = rnd_pcg_range(&d->rng,0,1); // if this is 0, we start with the left haplotype
        int up_to_crossover = 0;
        switch (map.chrs[chr].type) {
            case GSC_LINKAGEGROUP_SIMPLE:
                for (GSC_GENOLEN_T i = 0; i < map.chrs[chr].map.simple.n_markers; ++i) {
                    // is it time to invert which parent haplotype we're reading?
                    while (up_to_crossover < num_crossovers &&
                           map.chrs[chr].map.simple.dists[i] > crossover_where[up_to_crossover]) {
                        which = 1 - which;
                        up_to_crossover++;
                    }
                    output[2*(i + map.chrs[chr].map.simple.first_marker_index)] =
                            parent_genome[2*(i + map.chrs[chr].map.simple.first_marker_index) + which];
                }
                break;
            case GSC_LINKAGEGROUP_REORDER:
                for (GSC_GENOLEN_T i = 0; i < map.chrs[chr].map.reorder.n_markers; ++i) {
                    // is it time to invert which parent haplotype we're reading?
                    while (up_to_crossover < num_crossovers &&
                           map.chrs[chr].map.reorder.dists[i] > crossover_where[up_to_crossover]) {
                        which = 1 - which;
                        up_to_crossover++;
                    }
                    output[2*map.chrs[chr].map.reorder.marker_indexes[i]] =
                            parent_genome[2*map.chrs[chr].map.reorder.marker_indexes[i] + which];
                }
                break;
            default:
                break;
        }
    }
    GSC_DELETE_BUFFER(crossover_where);
}
 
void gsc_generate_doubled_haploid(gsc_SimData* d, 
                                  const char* parent_genome, 
                                  char* output, 
                                  const GSC_ID_T map_index) {
    /* For cache reasons it'll be better to copy-paste gsc_generate_gamete with
     * one extra line added to the inner loop, than to generate a single gamete
     * and then scan over `output` again to copy it. */
 
    // assumes rand is already seeded
    if (parent_genome == NULL) {
        fprintf(stderr, "Could not make this doubled haploid\n");
        return;
    }
    if (map_index >= d->genome.n_maps) {
        fprintf(stderr, "Could not generate this gamete: invalid map provided\n");
        return;
    }
    gsc_RecombinationMap map = d->genome.maps[map_index];
 
    // treat each chromosome separately.
    GSC_CREATE_BUFFER(crossover_where, double, 100);
    for (GSC_GENOLEN_T chr = 0; chr < d->genome.maps[map_index].n_chr; ++chr) {
 
        // Task 1: How many crossovers
        int num_crossovers;
        switch (map.chrs[chr].type) {
            case GSC_LINKAGEGROUP_SIMPLE:
                num_crossovers = gsc_randpoi(&d->rng, map.chrs[chr].map.simple.expected_n_crossovers);
                break;
            case GSC_LINKAGEGROUP_REORDER:
                num_crossovers = gsc_randpoi(&d->rng, map.chrs[chr].map.reorder.expected_n_crossovers);
                break;
            default:
                fprintf(stderr, "Linkage group type of group with index %lu of map with index %lu is corrupted\n", 
                        (long unsigned int) chr, (long unsigned int) map_index);
                num_crossovers = 0;
        }
 
        // Task 2: Find positions of all crossovers
        if (num_crossovers > crossover_wherecap) {
            GSC_STRETCH_BUFFER(crossover_where,num_crossovers);
        }
        for (int i = 0; i < num_crossovers; ++i) {
            crossover_where[i] = ((double)rand() / (double)RAND_MAX);
        }
        if (num_crossovers > 1) {
            qsort(crossover_where, num_crossovers, sizeof(double), gsc_helper_ascending_double_comparer);
        }
 
        // Task 3: Read off the gamete that those crossovers produce.
        int which = rnd_pcg_range(&d->rng,0,1); // if this is 0, we start with the left haplotype
        int up_to_crossover = 0;
        switch (map.chrs[chr].type) {
            case GSC_LINKAGEGROUP_SIMPLE:
                for (GSC_GENOLEN_T i = 0; i < map.chrs[chr].map.simple.n_markers; ++i) {
                    // is it time to invert which parent haplotype we're reading?
                    while (up_to_crossover < num_crossovers &&
                           map.chrs[chr].map.simple.dists[i] > crossover_where[up_to_crossover]) {
                        which = 1 - which;
                        up_to_crossover++;
                    }
                    GSC_GENOLEN_T pos = i + map.chrs[chr].map.simple.first_marker_index;
                    output[2*pos] = parent_genome[2*pos + which];
                    output[2*pos + 1] = output[2*pos];  // haploid doubling happens here
                }
                break;
            case GSC_LINKAGEGROUP_REORDER:
                for (GSC_GENOLEN_T i = 0; i < map.chrs[chr].map.reorder.n_markers; ++i) {
                    // is it time to invert which parent haplotype we're reading?
                    while (up_to_crossover < num_crossovers &&
                           map.chrs[chr].map.reorder.dists[i] > crossover_where[up_to_crossover]) {
                        which = 1 - which;
                        up_to_crossover++;
                    }
                    GSC_GENOLEN_T pos = map.chrs[chr].map.reorder.marker_indexes[i];
                    output[2*pos] = parent_genome[2*pos + which];
                    output[2*pos + 1] = output[2*pos]; // haploid doubling happens here
                }
                break;
            default:
                break;
        }
    }
    GSC_DELETE_BUFFER(crossover_where);
}
 
 
void gsc_generate_clone(gsc_SimData* d, 
                        const char* parent_genome, 
                        char* output) {
    for (GSC_GENOLEN_T j = 0; j < d->genome.n_markers; ++j) {
        output[2*j] = parent_genome[2*j];
        output[2*j + 1] = parent_genome[2*j + 1];
    }
    return;
}
 
static FILE* gsc_helper_genoptions_save_pedigrees_setup(const gsc_GenOptions g) {
    FILE* fp = NULL;
    if (g.will_save_pedigree_to_file) {                     
        char tmpname_p[NAME_LENGTH];
        if (g.filename_prefix != NULL) {
            strncpy(tmpname_p, g.filename_prefix,
                    sizeof(char)*(NAME_LENGTH-13));
        } else {
            strcpy(tmpname_p, "out");
        }
        strcat(tmpname_p, "-pedigree.txt");
        fp = fopen(tmpname_p, "w"); 
    }
    return fp;
}
static FILE* gsc_helper_genoptions_save_bvs_setup(const gsc_SimData* d, 
                                                  const gsc_GenOptions g, 
                                                  GSC_ID_T* effIndexp) {
    FILE* fe = NULL;
    if (g.will_save_bvs_to_file.id != GSC_NO_EFFECTSET.id) {
        *effIndexp = gsc_get_index_of_eff_set(d,g.will_save_bvs_to_file);
        if (*effIndexp != GSC_NA_IDX) {
            char tmpname_b[NAME_LENGTH];
            if (g.filename_prefix != NULL) {
                strncpy(tmpname_b, g.filename_prefix, 
                        sizeof(char)*(NAME_LENGTH-7));
            } else {
                strcpy(tmpname_b, "out");
            }
            strcat(tmpname_b, "-bv.txt");
            fe = fopen(tmpname_b, "w");
        }
    }
    return fe;
}
static FILE* gsc_helper_genoptions_save_genotypes_setup(const gsc_SimData* d, 
                                                        const gsc_GenOptions g) {
    FILE* fg = NULL;
    if (g.will_save_alleles_to_file) {
        char tmpname_g[NAME_LENGTH];
        if (g.filename_prefix != NULL) {
            strncpy(tmpname_g, g.filename_prefix,
                    sizeof(char)*(NAME_LENGTH-13));
        } else {
            strcpy(tmpname_g, "out");
        }
        strcat(tmpname_g, "-genotype.txt");
        fg = fopen(tmpname_g, "w");
        // Save genetic markers as header row.
        gsc_save_utility_genotypes(fg, NULL, d->genome.n_markers, d->genome.marker_names, GSC_FALSE);
    }
    return fg;
}
 
static void gsc_helper_genoptions_save_pedigrees(FILE* fp, 
                                                 gsc_SimData* d, 
                                                 gsc_AlleleMatrix* tosave) {
    if (fp) {
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter_fromAM(tosave, NO_GROUP);
        gsc_save_utility_pedigrees(fp, &it, GSC_TRUE, d->m);
        gsc_delete_bidirectional_iter(&it);
    }
}
static void gsc_helper_genoptions_save_bvs(FILE* fe, 
                                           gsc_MarkerEffects* effMatrices, 
                                           GSC_ID_T effIndex, 
                                           gsc_AlleleMatrix* tosave) {
    if (fe && effIndex != GSC_NA_IDX) {
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter_fromAM(tosave, NO_GROUP);
        gsc_save_utility_bvs(fe, &it, effMatrices + effIndex);
        gsc_delete_bidirectional_iter(&it);
    }
}
static void gsc_helper_genoptions_save_genotypes(FILE* fg, gsc_AlleleMatrix* tosave) {
    if (fg) {
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter_fromAM(tosave, NO_GROUP);
        gsc_save_utility_genotypes(fg, &it, tosave->n_markers, NULL, GSC_FALSE);
        gsc_delete_bidirectional_iter(&it);
    }
}
 
static void gsc_helper_genoptions_give_names_and_ids(gsc_AlleleMatrix* am, 
                                                     gsc_SimData* d, 
                                                     const gsc_GenOptions g) {
    if (g.will_name_offspring) {
        gsc_set_names(am, g.offspring_name_prefix, d->current_id.id, 0);
    }
    if (g.will_allocate_ids) {
        for (GSC_LOCALX_T j = 0; j < am->n_genotypes; ++j) {
            ++(d->current_id.id);
            am->ids[j] = d->current_id;
        }
    }
}
 
 
union gsc_datastore_make_genotypes { 
    struct {
        GSC_GLOBALX_T n_crosses;
        GSC_GLOBALX_T group_size;
        GSC_ID_T map_index;
        GSC_GLOBALX_T cap;
        GSC_GLOBALX_T* uses;
    } rand;
    struct {
        GSC_GLOBALX_T n_crosses;
        GSC_GLOBALX_T group1_size;
        GSC_GLOBALX_T group2_size;
        GSC_ID_T map1_index;
        GSC_ID_T map2_index;
        GSC_GLOBALX_T cap1;
        GSC_GLOBALX_T cap2;
        GSC_GLOBALX_T* uses1;
        GSC_GLOBALX_T* uses2;
    } rand_btwn;
    struct {
        GSC_GLOBALX_T n_crosses;
        GSC_ID_T map1_index;
        GSC_ID_T map2_index;
        GSC_GLOBALX_T* first_parents;
        GSC_GLOBALX_T* second_parents;
        GSC_GLOBALX_T bad_pairings;
    } targeted;
    struct {
        GSC_ID_T map_index;
        unsigned int n_gens_selfing;
    } selfing;
    struct {
        GSC_ID_T map_index; // needs to be in first spot to match selfing.map_index
    } doub_haps;
    struct {
        _Bool inherit_names;
        char* parent_name;
    } clones;
};
 
 
gsc_GroupNum gsc_scaffold_make_new_genotypes(gsc_SimData* d, 
                                             const gsc_GenOptions g,
                                             void* parentIterator, 
                                             union gsc_datastore_make_genotypes* datastore,
                                             int (*parentChooser)(void*, 
                                                                  union gsc_datastore_make_genotypes*,
                                                                  GSC_GLOBALX_T*, 
                                                                  gsc_ParentChoice[static 2]),
                                             void (*offspringGenerator)(gsc_SimData*, 
                                                                        union gsc_datastore_make_genotypes*, 
                                                                        gsc_ParentChoice[static 2], 
                                                                        gsc_GenoLocation) 
                                             ) {
    if (g.family_size < 1 || d == NULL ||
            parentChooser == NULL || offspringGenerator == NULL) {
        return GSC_NO_GROUP;
    }
    
    // create the buffer we'll use to save the output crosses before they're printed.
    gsc_AlleleMatrix* offspring = gsc_create_empty_allelematrix(d->genome.n_markers, d->n_labels, d->label_defaults, CONTIG_WIDTH);
    GSC_LOCALX_T fullness = 0;
    GSC_GLOBALX_T counter = 0;
    gsc_ParentChoice parents[2] = { { GSC_INVALID_GENO_LOCATION, GSC_NA }, 
                                    { GSC_INVALID_GENO_LOCATION, GSC_NA } };
 
    gsc_AlleleMatrix* last = NULL;
    gsc_GroupNum output_group = GSC_NO_GROUP;
    if (g.will_save_to_simdata) {
        last = d->m; // for saving to simdata
        while (last->next != NULL) {
            last = last->next;
        }
        output_group = gsc_get_new_group_num( d );
    }
 
    // open the output files, if applicable
    FILE* fp = gsc_helper_genoptions_save_pedigrees_setup(g);
    GSC_ID_T effIndex = GSC_NA_IDX;
    FILE* fe = gsc_helper_genoptions_save_bvs_setup(d,g,&effIndex);
    FILE* fg = gsc_helper_genoptions_save_genotypes_setup(d,g);
    
    //RPACKINSERT GetRNGstate();
    // loop through each combination
    while (parentChooser(parentIterator, datastore, &counter, parents)) {
        ++counter;
        for (GSC_GLOBALX_T f = 0; f < g.family_size; ++f, ++fullness) {
            //RPACKINSERT R_CheckUserInterrupt();
 
            // when offspring buffer is full, save these outcomes to the file.
            if (fullness >= CONTIG_WIDTH) {
                offspring->n_genotypes = CONTIG_WIDTH;
                gsc_helper_genoptions_give_names_and_ids(offspring, d, g);
                gsc_helper_genoptions_save_pedigrees(fp, d, offspring);
                gsc_helper_genoptions_save_bvs(fe, d->e, effIndex, offspring);
                gsc_helper_genoptions_save_genotypes(fg, offspring);
                
                if (g.will_save_to_simdata) {
                    last->next = offspring;
                    last = last->next;
                    offspring = gsc_create_empty_allelematrix(d->genome.n_markers, d->n_labels, d->label_defaults, CONTIG_WIDTH);
                }
                fullness = 0; //reset the count and start refilling the matrix
            }
            
            // do the cross.
            gsc_GenoLocation offspringPos = { .localAM=offspring, .localPos=fullness };
            offspringGenerator(d, datastore, parents, offspringPos);
            offspring->groups[fullness] = output_group;
            if (g.will_track_pedigree) {
                offspring->pedigrees[0][fullness] = gsc_get_id(parents[0].loc);
                offspring->pedigrees[1][fullness] = gsc_get_id(parents[1].loc);
            }
        }
    }
    //RPACKINSERT PutRNGstate();
 
    offspring->n_genotypes = fullness;
    gsc_helper_genoptions_give_names_and_ids(offspring, d, g);
    gsc_helper_genoptions_save_pedigrees(fp, d, offspring);
    gsc_helper_genoptions_save_bvs(fe, d->e, effIndex, offspring);
    gsc_helper_genoptions_save_genotypes(fg, offspring);
    
    if (fp) fclose(fp);
    if (fe) fclose(fe);
    if (fg) fclose(fg);
    
    if (counter > 0 && g.will_save_to_simdata) {
        last->next = offspring;
        d->n_groups++;
        gsc_condense_allele_matrix( d );
        return output_group;
    } else {
        gsc_delete_allele_matrix( offspring );
        return GSC_NO_GROUP;
    }
}
 
static int gsc_helper_parentchooser_cross_randomly(void* parentIterator, 
                                                   union gsc_datastore_make_genotypes* datastore, 
                                                   GSC_GLOBALX_T* counter, 
                                                   gsc_ParentChoice parents[static 2]) {
    gsc_RandomAccessIterator* it = (gsc_RandomAccessIterator*) parentIterator;
    
    GSC_GLOBALX_T parentixs[2] = { 0 };
 
    if (*counter < datastore->rand.n_crosses && 
        (datastore->rand.cap == 0 || (*counter) < datastore->rand.cap * datastore->rand.group_size)) {
        // get parents, randomly. Must not be identical or already been used too many times.
        parentixs[0] = gsc_randomdraw_replacementrules(it[0].d, 
                                                       datastore->rand.group_size,
                                                       datastore->rand.cap,
                                                       datastore->rand.uses,
                                                       GSC_NA_GLOBALX);
        parentixs[1] = gsc_randomdraw_replacementrules(it[0].d, 
                                                       datastore->rand.group_size,
                                                       datastore->rand.cap,
                                                       datastore->rand.uses,
                                                       parentixs[0]);
        
        if (datastore->rand.cap > 0) { 
            datastore->rand.uses[parentixs[0]] += 1; 
            datastore->rand.uses[parentixs[1]] += 1;
        }
        
        // Neither of these should fail, if nparents is good. 
        parents[0].loc = gsc_next_get_nth(parentIterator, parentixs[0]);
        parents[1].loc = gsc_next_get_nth(parentIterator, parentixs[1]);
        // Reiterate map. Might save us a read to not bother checking their values first.
        parents[0].mapindex = datastore->rand.map_index;
        parents[1].mapindex = datastore->rand.map_index;
        // This will cut short gsc_scaffold_make_new_genotypes execution if either parent is invalid.
        return GSC_IS_VALID_LOCATION(parents[0].loc) && GSC_IS_VALID_LOCATION(parents[1].loc);
    } else {
        return GSC_FALSE;
    }
}
 
static void gsc_helper_make_offspring_cross(gsc_SimData* d, 
                                            union gsc_datastore_make_genotypes* datastore, 
                                            gsc_ParentChoice parents[static 2], 
                                            gsc_GenoLocation putHere) {
    // (silly name)
    gsc_generate_gamete(d, gsc_get_alleles(parents[0].loc), (gsc_get_alleles(putHere)  ), parents[0].mapindex);
    gsc_generate_gamete(d, gsc_get_alleles(parents[1].loc), (gsc_get_alleles(putHere)+1), parents[1].mapindex);
}
 
static GSC_GLOBALX_T gsc_helper_random_cross_checks(gsc_SimData* d, 
                                                    const gsc_GroupNum from_group, 
                                                    const GSC_GLOBALX_T n_crosses, 
                                                    const GSC_GLOBALX_T cap) {
    GSC_GLOBALX_T g_size = gsc_get_group_size(d, from_group); // might be a better way to do this using the iterator.
    if (g_size == 0) {
        fprintf(stderr,"Group %lu does not exist\n", (long unsigned int) from_group.num);
        return 0;
    }
    
    if (n_crosses < 1) {
        fprintf(stderr,"Invalid n_crosses value provided: n_crosses must be greater than 0\n");
        return 0;
    }
 
    if (cap < 0) {
        fprintf(stderr,"Invalid cap value provided: cap can't be negative\n");
        return 0;
    }
    if (cap > 0 && cap*g_size < n_crosses) {
        fprintf(stderr,"Invalid cap value provided: cap of %lu uses on %lu parents too small to make %lu crosses\n",
                (long unsigned int) cap, (long unsigned int) g_size, (long unsigned int) n_crosses);
        return 0;
    }
 
    return g_size;
}   
 
gsc_GroupNum gsc_make_random_crosses(gsc_SimData* d, 
                                     const gsc_GroupNum from_group, 
                                     const GSC_GLOBALX_T n_crosses, 
                                     const GSC_GLOBALX_T cap,
                                     const gsc_MapID which_map, 
                                     const gsc_GenOptions g) {
    GSC_GLOBALX_T g_size = gsc_helper_random_cross_checks(d, from_group, n_crosses*2, cap);
    if (g_size == 0) {
        return GSC_NO_GROUP;
    } else if (g_size == 1) {
        fprintf(stderr,"Group %lu must contain multiple individuals to be able to perform random crossing\n", 
                (long unsigned int) from_group.num);
        return GSC_NO_GROUP;
    }
    if (d->genome.n_maps < 1) {
        fprintf(stderr,"Crossing requires at least one recombination map loaded\n");
        return GSC_NO_GROUP;
    }
    
    union gsc_datastore_make_genotypes paramstore = { 0 };
    paramstore.rand.n_crosses = n_crosses;
    paramstore.rand.group_size = g_size;
    paramstore.rand.map_index = 0;
    paramstore.rand.cap = cap;
    if (cap > 0) {
        paramstore.rand.uses = gsc_malloc_wrap(sizeof(*paramstore.rand.uses)*g_size,GSC_TRUE);
        memset(paramstore.rand.uses, 0, sizeof(*paramstore.rand.uses)*g_size);
    } else {
        paramstore.rand.uses = NULL;
    }
    
    if (which_map.id != NO_MAP.id) { 
        paramstore.rand.map_index = gsc_get_index_of_map(d, which_map); 
    }
    if (paramstore.rand.map_index == GSC_NA_IDX) {
        fprintf(stderr,"Could not find recombination map with identifier %lu\n", (long unsigned int) which_map.id);
        return GSC_NO_GROUP;
    }
    
    RandomAccessIterator parentit = gsc_create_randomaccess_iter( d, from_group);
    
    gsc_GroupNum offspring = gsc_scaffold_make_new_genotypes(d, g, (void*) &parentit,
                                                             &paramstore,
                                                             gsc_helper_parentchooser_cross_randomly,
                                                             gsc_helper_make_offspring_cross );
 
    gsc_delete_randomaccess_iter(&parentit);
    GSC_FREE(paramstore.rand.uses);
    return offspring;
}
 
GSC_GLOBALX_T gsc_randomdraw_replacementrules(gsc_SimData* d, 
                                              GSC_GLOBALX_T max, 
                                              GSC_GLOBALX_T cap, 
                                              GSC_GLOBALX_T* member_uses, 
                                              GSC_GLOBALX_T noCollision) {
    if (max < 1 || (max == 1 && noCollision == 0)) {
        return GSC_NA_GLOBALX;
    }
    if (max > INT_MAX) {
        fprintf(stderr, "Drawing a random number with a max of %lu is not supported on the C version"
                "with the rnd library. If the max is greater than %d, probabilistic uniformity may be lost"
                "or an infinite loop may occur.", (long unsigned int) max, INT_MAX);
    }
    
    GSC_GLOBALX_T parentix = 0;
    if (cap > 0) {  // n uses of each parent is capped at a number cap.
        do {
            parentix = rnd_pcg_range(&d->rng,0,max - 1);
        } while (parentix == noCollision || member_uses[parentix] >= cap);
    } else { // no cap on usage of each parent.
        do {
            parentix = rnd_pcg_range(&d->rng,0,max - 1);
        } while (parentix == noCollision);
    }
    return parentix;
}
 
static int gsc_helper_parentchooser_cross_randomly_between(void* parentIterator, 
                                                           union gsc_datastore_make_genotypes* datastore, 
                                                           GSC_GLOBALX_T* counter,
                                                           gsc_ParentChoice parents[static 2]) {
    // caller function should guarantee that nparents is not 1. How would you make a nonselfed cross then?
    gsc_RandomAccessIterator* it = (gsc_RandomAccessIterator*) parentIterator;
    size_t parentixs[2] = { 0 };
    
    if (*counter < datastore->rand_btwn.n_crosses &&
        (datastore->rand_btwn.cap1 == 0 || (*counter) < datastore->rand_btwn.cap1 * datastore->rand_btwn.group1_size) &&
        (datastore->rand_btwn.cap2 == 0 || (*counter) < datastore->rand_btwn.cap2 * datastore->rand_btwn.group2_size)) {
        // get parents, randomly. Must not be identical or already been used too many times.
        parentixs[0] = gsc_randomdraw_replacementrules(it[0].d, 
                                                       datastore->rand_btwn.group1_size,
                                                       datastore->rand_btwn.cap1, 
                                                       datastore->rand_btwn.uses1, 
                                                       GSC_NA_GLOBALX);
        parentixs[1] = gsc_randomdraw_replacementrules(it[1].d, 
                                                       datastore->rand_btwn.group2_size,
                                                       datastore->rand_btwn.cap2, 
                                                       datastore->rand_btwn.uses2, 
                                                       GSC_NA_GLOBALX);
            
        if (datastore->rand_btwn.cap1 > 0) { 
            datastore->rand_btwn.uses1[parentixs[0]] += 1; 
        } 
        if (datastore->rand_btwn.cap2 > 0) {
            datastore->rand_btwn.uses2[parentixs[1]] += 1;
        }
 
        parents[0].loc = gsc_next_get_nth(it+0, parentixs[0]);
        parents[1].loc = gsc_next_get_nth(it+1, parentixs[1]);
        parents[0].mapindex = datastore->rand_btwn.map1_index;
        parents[1].mapindex = datastore->rand_btwn.map2_index;
        return GSC_IS_VALID_LOCATION(parents[0].loc) && GSC_IS_VALID_LOCATION(parents[1].loc);
    }
    return GSC_FALSE;
}
 
gsc_GroupNum gsc_make_random_crosses_between(gsc_SimData*d, 
                                             const gsc_GroupNum group1, 
                                             const gsc_GroupNum group2, 
                                             const GSC_GLOBALX_T n_crosses,
                                             const GSC_GLOBALX_T cap1, 
                                             const GSC_GLOBALX_T cap2, 
                                             const gsc_MapID map1, 
                                             const gsc_MapID map2, 
                                             const gsc_GenOptions g) {
    GSC_GLOBALX_T group1_size = gsc_helper_random_cross_checks(d, group1, n_crosses, cap1);
    GSC_GLOBALX_T group2_size = gsc_helper_random_cross_checks(d, group2, n_crosses, cap2);
    if (group1_size == 0 || group2_size == 0) {
        return GSC_NO_GROUP;
    }
    if (d->genome.n_maps < 1) {
        fprintf(stderr,"Crossing requires at least one recombination map loaded\n");
        return GSC_NO_GROUP;
    }
    
    union gsc_datastore_make_genotypes paramstore;
    paramstore.rand_btwn.n_crosses = n_crosses;
    paramstore.rand_btwn.group1_size = group1_size;
    paramstore.rand_btwn.group2_size = group2_size;
    paramstore.rand_btwn.map1_index = 0;
    paramstore.rand_btwn.map2_index = 0;
    paramstore.rand_btwn.cap1 = cap1;
    paramstore.rand_btwn.cap2 = cap2;
    if (cap1 > 0) {
        paramstore.rand_btwn.uses1 = 
            gsc_malloc_wrap(sizeof(*paramstore.rand_btwn.uses1)*group1_size,GSC_TRUE);
        memset(paramstore.rand_btwn.uses1, 0, sizeof(*paramstore.rand_btwn.uses1)*group1_size);
    } else {
        paramstore.rand_btwn.uses1 = NULL;
    }
    if (cap2 > 0) {
        paramstore.rand_btwn.uses2 = 
            gsc_malloc_wrap(sizeof(*paramstore.rand_btwn.uses2)*group2_size,GSC_TRUE);
        memset(paramstore.rand_btwn.uses2, 0, sizeof(*paramstore.rand_btwn.uses2)*group2_size);
    } else {
        paramstore.rand_btwn.uses2 = NULL;
    }
    
    if (map1.id != NO_MAP.id) { 
        paramstore.rand_btwn.map1_index = gsc_get_index_of_map(d, map1); 
    }
    if (paramstore.rand_btwn.map1_index == GSC_NA_IDX) {
        fprintf(stderr,"Could not find recombination map with identifier %lu\n", (long unsigned int) map1.id);
        return GSC_NO_GROUP;
    }
    if (map2.id != NO_MAP.id) { 
        paramstore.rand_btwn.map2_index = gsc_get_index_of_map(d, map2); 
    }
    if (paramstore.rand_btwn.map2_index == GSC_NA_IDX) {
        fprintf(stderr,"Could not find recombination map with identifier %lu\n", (long unsigned int) map2.id);
        return GSC_NO_GROUP;
    }
 
    gsc_RandomAccessIterator parentit[2] = { gsc_create_randomaccess_iter( d, group1 ),
                                             gsc_create_randomaccess_iter( d, group2 ) };
                                                
    gsc_GroupNum offspring = gsc_scaffold_make_new_genotypes(d, g, (void*) parentit, 
                                                             &paramstore,
                                                             gsc_helper_parentchooser_cross_randomly_between,
                                                             gsc_helper_make_offspring_cross );
 
    gsc_delete_randomaccess_iter(&parentit[0]);
    gsc_delete_randomaccess_iter(&parentit[1]);
    GSC_FREE(paramstore.rand_btwn.uses1);
    GSC_FREE(paramstore.rand_btwn.uses2);
    return offspring;
    
}
 
static int gsc_helper_parentchooser_cross_targeted(void* parentIterator, 
                                                   union gsc_datastore_make_genotypes* datastore, 
                                                   GSC_GLOBALX_T* counter,
                                                   gsc_ParentChoice parents[static 2]) {
    gsc_RandomAccessIterator* it = (gsc_RandomAccessIterator*) parentIterator;
    
    while (*counter < datastore->targeted.n_crosses) {
        if  (datastore->targeted.first_parents[*counter] != GSC_NA_GLOBALX && 
             datastore->targeted.second_parents[*counter] != GSC_NA_GLOBALX) {
            // We only try to "get nth" if it seems like a potentially reasonable value
            parents[0].loc = gsc_next_get_nth(it, datastore->targeted.first_parents[*counter]);
            parents[1].loc = gsc_next_get_nth(it, datastore->targeted.second_parents[*counter]);
            parents[0].mapindex = datastore->targeted.map1_index;
            parents[1].mapindex = datastore->targeted.map2_index;
            
            if (GSC_IS_VALID_LOCATION(parents[0].loc) && GSC_IS_VALID_LOCATION(parents[1].loc)) {
                return GSC_TRUE;
            }
        }
        
        // If this was not a valid pair of parents, skip them and move on to the next pair.
        ++ datastore->targeted.bad_pairings;
        ++ (*counter);
    }
    return GSC_FALSE; 
}
 
gsc_GroupNum gsc_make_targeted_crosses(gsc_SimData* d, 
                                       const size_t n_combinations, 
                                       const GSC_GLOBALX_T* firstParents, 
                                       const GSC_GLOBALX_T* secondParents,
                                       const gsc_MapID map1, 
                                       const gsc_MapID map2, 
                                       const gsc_GenOptions g) {
    if (n_combinations < 1) {
        fprintf(stderr,"Invalid n_combinations value provided: n_combinations must be greater than 0\n");
        return GSC_NO_GROUP;
    }
    if (d->genome.n_maps < 1) {
        fprintf(stderr,"Crossing requires at least one recombination map loaded\n");
        return GSC_NO_GROUP;
    }
    
    union gsc_datastore_make_genotypes paramstore;
    paramstore.targeted.n_crosses = n_combinations;
    paramstore.targeted.bad_pairings = 0;
    paramstore.targeted.map1_index = 0;
    paramstore.targeted.map2_index = 0;
    // casting away const but is being used as readonly
    paramstore.targeted.first_parents = (GSC_GLOBALX_T*) firstParents;
    paramstore.targeted.second_parents = (GSC_GLOBALX_T*) secondParents;
    
    if (map1.id != NO_MAP.id) { 
        paramstore.targeted.map1_index = gsc_get_index_of_map(d, map1); 
    }
    if (paramstore.targeted.map1_index == GSC_NA_IDX) {
        fprintf(stderr,"Could not find recombination map with identifier %lu\n", (long unsigned int) map1.id);
        return GSC_NO_GROUP;
    }
    if (map2.id != NO_MAP.id) { 
        paramstore.targeted.map2_index = gsc_get_index_of_map(d, map2); 
    }
    if (paramstore.targeted.map2_index == GSC_NA_IDX) {
        fprintf(stderr,"Could not find recombination map with identifier %lu\n", (long unsigned int) map2.id);
        return GSC_NO_GROUP;
    }
    
    gsc_RandomAccessIterator parentit = gsc_create_randomaccess_iter( d, GSC_NO_GROUP );
    
    gsc_GroupNum offspring = gsc_scaffold_make_new_genotypes(d, g, (void*) &parentit,
                                                             &paramstore,
                                                             gsc_helper_parentchooser_cross_targeted,
                                                             gsc_helper_make_offspring_cross );
 
    gsc_delete_randomaccess_iter(&parentit);
    if (paramstore.targeted.bad_pairings > 0) {
        fprintf(stderr,"Targeted crossing failed for %lu out of the %lu requested pairings due to one or both genotype indexes being invalid\n", (long unsigned int) paramstore.targeted.bad_pairings, (long unsigned int) n_combinations);
    }
    if (n_combinations - paramstore.targeted.bad_pairings == 0) {
        return GSC_NO_GROUP;
    } 
    return offspring;
}
 
static int gsc_helper_parentchooser_selfing(void* parentIterator, 
                                            union gsc_datastore_make_genotypes* datastore, 
                                            GSC_GLOBALX_T* counter, 
                                            gsc_ParentChoice parents[static 2]) {
    gsc_BidirectionalIterator* it = (gsc_BidirectionalIterator*) parentIterator;
    
    parents[0].loc = gsc_next_forwards(it);
    parents[0].mapindex = datastore->selfing.map_index;
    parents[1] = parents[0];
 
    return GSC_IS_VALID_LOCATION(parents[0].loc);
}
 
static void gsc_helper_make_offspring_self_n_times(gsc_SimData* d, 
                                                   union gsc_datastore_make_genotypes* datastore, 
                                                   gsc_ParentChoice parents[static 2], 
                                                   gsc_GenoLocation putHere) {
    unsigned int n = datastore->selfing.n_gens_selfing;
    
    // error checking parents are the same is not done.
    // error checking n >= 1 is not done.
    
    char* tmpparent = gsc_get_alleles(parents[0].loc);
    GSC_ID_T map = parents[0].mapindex;
    GSC_CREATE_BUFFER(tmpchild,char,d->genome.n_markers<<1);
    char* output = gsc_get_alleles(putHere);
    int n_oddness = n % 2; 
    for (unsigned int i = 0; i < n; ++i) {
        if (i % 2 == n_oddness) {
            gsc_generate_gamete(d, tmpparent, tmpchild, map);
            gsc_generate_gamete(d, tmpparent, tmpchild+1, map);
            tmpparent = tmpchild;
        } else {
            gsc_generate_gamete(d, tmpparent, output, map);
            gsc_generate_gamete(d, tmpparent, output+1, map);
            tmpparent = output;
        }
    }
    GSC_DELETE_BUFFER(tmpchild);
}
 
gsc_GroupNum gsc_self_n_times(gsc_SimData* d, 
                              const unsigned int n, 
                              const gsc_GroupNum group, 
                              const gsc_MapID which_map, 
                              const gsc_GenOptions g) {
    /*int group_size = gsc_get_group_size( d, group);
    if (group_size < 1) {
        fprintf(stderr,"Group %d does not exist.\n", group.num);
        return GSC_NO_GROUP;
    }*/
    if (n < 1) {
        fprintf(stderr,"Invalid n value provided: Number of generations must be greater than 0\n");
        return GSC_NO_GROUP;
    }
    if (d->genome.n_maps == 0) {
        fprintf(stderr,"Selfing requires at least one recombination map loaded\n");
        return GSC_NO_GROUP;
    }
        
    union gsc_datastore_make_genotypes paramstore;
    paramstore.selfing.map_index = 0;
    paramstore.selfing.n_gens_selfing = n;
 
    if (which_map.id != NO_MAP.id) { 
        paramstore.selfing.map_index = gsc_get_index_of_map(d, which_map); 
    }
    if (paramstore.selfing.map_index == GSC_NA_IDX) {
        fprintf(stderr,"Could not find recombination map with identifier %lu\n", (long unsigned int) which_map.id);
        return GSC_NO_GROUP;                          
    }
    
    gsc_BidirectionalIterator parentit = gsc_create_bidirectional_iter( d, group );
    
    return gsc_scaffold_make_new_genotypes(d, g, (void*) &parentit,
                                           &paramstore,
                                           gsc_helper_parentchooser_selfing,
                                           gsc_helper_make_offspring_self_n_times );
}
 
static void gsc_helper_make_offspring_doubled_haploids(gsc_SimData* d, 
                                                       union gsc_datastore_make_genotypes* datastore, 
                                                       gsc_ParentChoice parents[static 2], 
                                                       gsc_GenoLocation putHere) {
    gsc_generate_doubled_haploid(d, 
                                 gsc_get_alleles(parents[0].loc), 
                                 gsc_get_alleles(putHere), 
                                 parents[0].mapindex);
}
 
gsc_GroupNum gsc_make_doubled_haploids(gsc_SimData* d, 
                                       const gsc_GroupNum group, 
                                       const gsc_MapID which_map, 
                                       const gsc_GenOptions g) {
    /*int group_size = gsc_get_group_size( d, group);
    if (group_size < 1) {
        fprintf(stderr,"Group %d does not exist.\n", group.num);
        return GSC_NO_GROUP;
    }*/
    if (d->genome.n_maps == 0) {
        fprintf(stderr,"Crossing requires at least one recombination map loaded\n");
        return GSC_NO_GROUP;
    }
    
    union gsc_datastore_make_genotypes paramstore = { 0 };
    
    if (which_map.id != NO_MAP.id) { 
        paramstore.doub_haps.map_index = gsc_get_index_of_map(d, which_map); 
    }
    if (paramstore.doub_haps.map_index == GSC_NA_IDX) {
        fprintf(stderr,"Could not find recombination map with identifier %lu\n", (long unsigned int) which_map.id);
        return GSC_NO_GROUP;
    }                                    
    
    gsc_BidirectionalIterator parentit = gsc_create_bidirectional_iter( d, group );
    
    return gsc_scaffold_make_new_genotypes(d, g, (void*) &parentit,
                                           &paramstore,
                                           gsc_helper_parentchooser_selfing,
                                           gsc_helper_make_offspring_doubled_haploids );
}
 
static int gsc_helper_parentchooser_cloning(void* parentIterator, 
                                            union gsc_datastore_make_genotypes* datastore, 
                                            GSC_GLOBALX_T* counter, 
                                            gsc_ParentChoice parents[static 2]) {
    gsc_BidirectionalIterator* it = (gsc_BidirectionalIterator*) parentIterator;
    
    parents[0].loc = gsc_next_forwards(it);
    parents[1] = parents[0];
 
    if (GSC_IS_VALID_LOCATION(parents[0].loc)) {
        if (datastore->clones.inherit_names) {
            datastore->clones.parent_name = gsc_get_name(parents[0].loc);
        }
        return GSC_TRUE;
    } else {
        return GSC_FALSE;
    }
}
 
static void gsc_helper_make_offspring_clones(gsc_SimData* d, 
                                             union gsc_datastore_make_genotypes* datastore, 
                                             gsc_ParentChoice parents[static 2], 
                                             gsc_GenoLocation putHere) {
    if (datastore->clones.inherit_names && datastore->clones.parent_name != NULL) {
        char* tmpname = gsc_malloc_wrap(sizeof(char)*(strlen(datastore->clones.parent_name) + 1),GSC_TRUE);
        strcpy(tmpname, datastore->clones.parent_name);
        gsc_set_name(putHere,tmpname);
    }
    
    gsc_generate_clone(d, gsc_get_alleles(parents[0].loc), gsc_get_alleles(putHere));
}
 
gsc_GroupNum gsc_make_clones(gsc_SimData* d, 
                             const gsc_GroupNum group, 
                             const _Bool inherit_names, 
                             gsc_GenOptions g) {
    /*int group_size = gsc_get_group_size( d, group);
    if (group_size < 1) {
        fprintf(stderr,"Group %d does not exist.\n", group.num);
        return GSC_NO_GROUP;
    }*/
    
    union gsc_datastore_make_genotypes paramstore; 
    paramstore.clones.inherit_names = inherit_names;
    
    gsc_BidirectionalIterator parentit = gsc_create_bidirectional_iter( d, group );
    
    return gsc_scaffold_make_new_genotypes(d, g, (void*) &parentit,
                                           &paramstore,
                                           gsc_helper_parentchooser_cloning,
                                           gsc_helper_make_offspring_clones );
}
 
 
gsc_GroupNum gsc_make_all_unidirectional_crosses(gsc_SimData* d, 
                                                 const gsc_GroupNum from_group, 
                                                 const gsc_MapID mapID, 
                                                 const gsc_GenOptions g) {
    GSC_GLOBALX_T group_size = gsc_get_group_size( d, from_group );
    if (group_size < 2) {
        if (group_size == 1) {
            fprintf(stderr,"Group %lu does not have enough members to perform crosses\n", (long unsigned int) from_group.num);
        } else {
            fprintf(stderr,"Group %lu does not exist\n", (long unsigned int) from_group.num);
        }
        return GSC_NO_GROUP;
    }
    GSC_CREATE_BUFFER(group_indexes,GSC_GLOBALX_T,group_size);
    gsc_get_group_indexes( d, from_group, group_size, group_indexes );
 
    // number of crosses = number of entries in upper triangle of matrix
    //    = half of (n entries in matrix - length of diagonal)
    //    = half of (lmatrix * lmatrix - lmatrix);
    GSC_GLOBALX_T n_crosses = group_size * (group_size - 1) / 2; //* g.family_size;
 
    GSC_CREATE_BUFFER(combos0,GSC_GLOBALX_T,n_crosses);
    GSC_CREATE_BUFFER(combos1,GSC_GLOBALX_T,n_crosses);
    GSC_GLOBALX_T* combinations[2] = {combos0, combos1};
    GSC_GLOBALX_T cross_index = 0;
    for (GSC_GLOBALX_T i = 0; i < group_size; ++i) {
        for (GSC_GLOBALX_T j = i + 1; j < group_size; ++j) {
            combinations[0][cross_index] = group_indexes[i];
            combinations[1][cross_index] = group_indexes[j];
 
            ++cross_index;
        }
    }
 
    GSC_DELETE_BUFFER(group_indexes);
    gsc_GroupNum out = gsc_make_targeted_crosses(d, n_crosses, combinations[0], combinations[1], mapID, mapID, g);
    GSC_DELETE_BUFFER(combos0);
    GSC_DELETE_BUFFER(combos1);
    return out;
}
 
gsc_GroupNum gsc_make_n_crosses_from_top_m_percent(gsc_SimData* d, const int n, const int m, const gsc_GroupNum group,
                                                   const gsc_MapID mapID, const gsc_EffectID effID, const gsc_GenOptions g) {
    fprintf(stderr, "Function gsc_make_n_crosses_from_top_m_percent is deprecated."
            "It behaved unintuitively and goes against genomicSimulation principles on division of functionality\n");
 
    return NO_GROUP;
}
 
gsc_GroupNum gsc_make_crosses_from_file(gsc_SimData* d, 
                                        const char* input_file, 
                                        const gsc_MapID map1, 
                                        const gsc_MapID map2, 
                                        const gsc_GenOptions g) {
    struct gsc_TableSize t = gsc_get_file_dimensions(input_file, '\t');
    if (t.num_rows < 1) {
        fprintf(stderr, "No crosses exist in that file\n");
        return GSC_NO_GROUP;
    }
 
    //open file
    FILE* fp;
    if ((fp = fopen(input_file, "r")) == NULL) {
        fprintf(stderr, "Failed to open file %s.\n", input_file); exit(1);
    }
 
    GSC_CREATE_BUFFER(combos0,GSC_GLOBALX_T,t.num_rows);
    GSC_CREATE_BUFFER(combos1,GSC_GLOBALX_T,t.num_rows);
    GSC_GLOBALX_T* combinations[2] = {combos0,combos1};
    char buffer[2][NAME_LENGTH];
    // for each row in file
    GSC_GLOBALX_T bufferi = 0;
    for (int filei = 0; filei < t.num_rows; ++filei) {
        // load the four grandparents
        fscanf(fp, "%s %s \n", buffer[0], buffer[1]);
        combinations[0][bufferi] = gsc_get_index_of_name(d->m, buffer[0]);
        combinations[1][bufferi] = gsc_get_index_of_name(d->m, buffer[1]);
        if (combinations[0][bufferi] < 0 || combinations[1][bufferi] < 0) {
            fprintf(stderr, "Parents on file %s line %lu could not be found\n", input_file, (long unsigned int) filei);
        } else {
            ++bufferi;
        }
    }
 
    fclose(fp);
    gsc_GroupNum out = gsc_make_targeted_crosses(d, bufferi, combinations[0], combinations[1], map1, map2, g);
    GSC_DELETE_BUFFER(combos0);
    GSC_DELETE_BUFFER(combos1);
    return out;
}
 
gsc_GroupNum gsc_make_double_crosses_from_file(gsc_SimData* d, 
                                               const char* input_file, 
                                               const gsc_MapID map1, 
                                               const gsc_MapID map2, 
                                               const gsc_GenOptions g) {
    struct gsc_TableSize t = gsc_get_file_dimensions(input_file, '\t');
    if (t.num_rows < 1) {
        fprintf(stderr, "No crosses exist in that file\n");
        return GSC_NO_GROUP;
    }
 
    //open file
    FILE* fp;
    if ((fp = fopen(input_file, "r")) == NULL) {
        fprintf(stderr, "Failed to open file %s.\n", input_file); exit(1);
    }
 
    GSC_CREATE_BUFFER(combos0,GSC_GLOBALX_T,t.num_rows);
    GSC_CREATE_BUFFER(combos1,GSC_GLOBALX_T,t.num_rows);
    GSC_GLOBALX_T* combinations[2] = {combos0,combos1};
    char buffer[4][NAME_LENGTH];
    const char* to_buffer[] = {buffer[0], buffer[1], buffer[2], buffer[3]};
    gsc_PedigreeID g0_id[4];
    GSC_GLOBALX_T f1_i[2];
    // for each row in file
    for (GSC_GLOBALX_T i = 0; i < t.num_rows; ++i) {
        // load the four grandparents
        fscanf(fp, "%s %s %s %s \n", buffer[0], buffer[1], buffer[2], buffer[3]);
        gsc_get_ids_of_names(d->m, 4, to_buffer, g0_id);
        if (g0_id[0].id == GSC_NO_PEDIGREE.id || g0_id[1].id == GSC_NO_PEDIGREE.id || g0_id[2].id == GSC_NO_PEDIGREE.id || g0_id[3].id == GSC_NO_PEDIGREE.id) {
            fprintf(stderr, "Could not go ahead with the line %lu cross - g0 names not in records\n", 
                    (long unsigned int) i);
            combinations[0][i] = GSC_NA_GLOBALX;
            combinations[1][i] = GSC_NA_GLOBALX;
            continue;
        }
 
        // identify two parents
        f1_i[0] = gsc_get_index_of_child(d->m, g0_id[0], g0_id[1]);
        f1_i[1] = gsc_get_index_of_child(d->m, g0_id[2], g0_id[3]);
        if (f1_i[0] < 0 || f1_i[1] < 0) {
            // try different permutations of the four grandparents.
            f1_i[0] = gsc_get_index_of_child(d->m, g0_id[0], g0_id[2]);
            f1_i[1] = gsc_get_index_of_child(d->m, g0_id[1], g0_id[3]);
            if (f1_i[0] < 0 || f1_i[1] < 0) {
                f1_i[0] = gsc_get_index_of_child(d->m, g0_id[0], g0_id[3]);
                f1_i[1] = gsc_get_index_of_child(d->m, g0_id[1], g0_id[2]);
                if (f1_i[0] < 0 || f1_i[1] < 0) {
                    fprintf(stderr, "Could not go ahead with the line %lu cross - f1 children do not exist for this quartet\n", 
                             (long unsigned int) i);
                    combinations[0][i] = GSC_NA_GLOBALX;
                    combinations[1][i] = GSC_NA_GLOBALX;
                    continue;
                }
            }
        }
 
        //add them to a combinations list
        combinations[0][i] = f1_i[0];
        combinations[1][i] = f1_i[1];
 
    }
 
    fclose(fp);
    gsc_GroupNum out = gsc_make_targeted_crosses(d, t.num_rows, combinations[0], combinations[1], 
                                                 map1, map2, g);
    GSC_DELETE_BUFFER(combos0);
    GSC_DELETE_BUFFER(combos1);
    return out;
}
 
 
/*--------------------------------Fitness------------------------------------*/
 
gsc_GroupNum gsc_split_by_bv(gsc_SimData* d, 
                             const gsc_GroupNum group, 
                             const gsc_EffectID effID, 
                             const GSC_GLOBALX_T top_n, 
                             const _Bool lowIsBest) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        return GSC_NO_GROUP;
    }
 
    GSC_GLOBALX_T group_size = gsc_get_group_size( d, group );
    if (group_size == 0) {
        fprintf(stderr,"Group %lu does not exist\n", (long unsigned int) group.num);
        return GSC_NO_GROUP;
    }
    GSC_CREATE_BUFFER(group_indexes,GSC_GLOBALX_T,group_size);
    gsc_get_group_indexes( d, group, group_size, group_indexes );
    
    if (group_size <= top_n) {
        // well we'll just have to move em all
        gsc_GroupNum migration = gsc_make_group_from(d, group_size, group_indexes);
        return migration;
    }
    
    // This should be ordered the same as the indexes
    gsc_DecimalMatrix fits = gsc_calculate_bvs( d, group, effID ); // 1 by group_size matrix
    
    // get an array of pointers to those fitnesses
    GSC_CREATE_BUFFER(p_fits,double*,fits.dim2);
    for (size_t i = 0; i < fits.dim2; i++) {
        p_fits[i] = &(fits.matrix[0][i]);
    }
 
    // sort descending
    if (lowIsBest) {
        qsort(p_fits, fits.dim2, sizeof(double*), gsc_helper_ascending_pdouble_comparer);
    } else {
        qsort(p_fits, fits.dim2, sizeof(double*), gsc_helper_descending_pdouble_comparer);
    }
 
    // save the indexes of the best n
    GSC_CREATE_BUFFER(top_individuals,GSC_GLOBALX_T,top_n);
    for (GSC_GLOBALX_T i = 0; i < top_n; i++) {
        top_individuals[i] = group_indexes[p_fits[i] - fits.matrix[0]];
    }
    gsc_delete_dmatrix(&fits);
    GSC_DELETE_BUFFER(p_fits);
    GSC_DELETE_BUFFER(group_indexes);
 
    // send those n to a new group
    gsc_GroupNum out = gsc_make_group_from(d, top_n, top_individuals);
    GSC_DELETE_BUFFER(top_individuals);
    return out;
}
 
gsc_DecimalMatrix gsc_calculate_bvs(const gsc_SimData* d, 
                                    const gsc_GroupNum group, 
                                    const gsc_EffectID effID) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        return gsc_generate_zero_dmatrix(0, 0);
    }
 
    // casing away const but I promise not to use the iterator to change anything
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, group);
    
    gsc_DecimalMatrix bvs = gsc_calculate_utility_bvs(&it, d->e + effIndex);
 
    gsc_delete_bidirectional_iter(&it);
    return bvs;
}
 
gsc_DecimalMatrix gsc_calculate_utility_bvs(gsc_BidirectionalIterator* targets, 
                                            const gsc_MarkerEffects* effset) {
    if (targets == NULL || effset == NULL) {
        fprintf(stderr, "Either targets or marker effects were not provided\n"); 
        return gsc_generate_zero_dmatrix(0, 0);
    }
    gsc_MarkerEffects e = *effset; // trivial line. just for easier typing
 
    GSC_CREATE_BUFFER(sum, double, 50);
    GSC_GLOBALX_T n_genotypes = 0;
    
    gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(targets);
    while (IS_VALID_LOCATION(loc)) {
        if (n_genotypes >= sumcap) {
            GSC_STRETCH_BUFFER(sum, 2*n_genotypes);
        }
        
        sum[n_genotypes] = 0;
        
        //RPACKINSERT R_CheckUserInterrupt();
        char* genotype = gsc_get_alleles(loc);
        for (GSC_GENOLEN_T m = 0; m < e.n_markers; ++m) {
            double msum = 0.;
            
            for (GSC_GENOLEN_T eix = ((m > 0) ? e.cumn_alleles[m-1] : 0); eix < e.cumn_alleles[m]; ++eix) {
                double asum = ( (e.allele[eix] == genotype[2*m]) + 
                                (e.allele[eix] == genotype[2*m+1])  ) * e.eff[eix];
                msum += asum; // accumulate action
            }
            
            sum[n_genotypes] += msum; // accumulate action
        }
        
        ++n_genotypes;
        loc = gsc_next_forwards(targets);
    }
    
    if (e.centre != NULL) {
        double summedcentres = 0.;
        for (GSC_GENOLEN_T m = 0; m < e.n_markers; ++m) {
            summedcentres += e.centre[m];
        }
        
        for (GSC_GLOBALX_T i = 0; i < n_genotypes; ++i) {
            sum[i] -= summedcentres;
        }
    }
    
    gsc_DecimalMatrix out = gsc_generate_zero_dmatrix(1, 0);
    GSC_FINALISE_BUFFER(sum,out.matrix[0],n_genotypes);
    out.dim2 = n_genotypes;
    return out;
}
 
gsc_DecimalMatrix gsc_calculate_allele_counts(const gsc_SimData* d, 
                                              const gsc_GroupNum group, 
                                              const char allele) {
    GSC_CREATE_BUFFER(counts, double*, 50);
    GSC_GLOBALX_T n_genotypes = 0;
    // casing away const but I promise not to use the iterator to change anything
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, group);
 
    gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(&it);
    while (IS_VALID_LOCATION(loc)) {
        if (n_genotypes >= countscap) {
            GSC_STRETCH_BUFFER(counts, 2*n_genotypes);
        }
        
        //RPACKINSERT R_CheckUserInterrupt();
        counts[n_genotypes] = gsc_malloc_wrap(sizeof(*counts[n_genotypes])*d->genome.n_markers, GSC_TRUE);
        char* genotype = gsc_get_alleles(loc);
        for (GSC_GENOLEN_T m = 0; m < d->genome.n_markers; ++m) { // loop parallelisable
            counts[n_genotypes][m] = (genotype[2*m] == allele) + (genotype[2*m+1] == allele);
        }
        
        ++n_genotypes;
        loc = gsc_next_forwards(&it);
    }
    gsc_delete_bidirectional_iter(&it);
 
    gsc_DecimalMatrix out;
    GSC_FINALISE_BUFFER(counts,out.matrix,n_genotypes);
    out.dim1 = n_genotypes;
    out.dim2 = d->genome.n_markers;
    return out;
}
 
 
gsc_MarkerBlocks gsc_create_evenlength_blocks_each_chr(const gsc_SimData* d, 
                                                       const gsc_MapID mapid, 
                                                       const GSC_ID_T n) {
    gsc_MarkerBlocks blocks;
    blocks.num_blocks = 0;
 
    if (d->genome.n_maps < 1) {
        fprintf(stderr,"Creating blocks by chromosome length requires at least one recombination map loaded\n");
        return blocks;
    }
    GSC_ID_T mapix = 0;
    if (mapid.id != NO_MAP.id) { mapix = gsc_get_index_of_map(d, mapid); }
    if (mapix >= d->genome.n_maps) {
        fprintf(stderr,"We don't have that recombination maps loaded. Using default map\n");
        mapix = 0;
    }
    gsc_RecombinationMap map = d->genome.maps[mapix];
 
    if (n < 1) {
        fprintf(stderr,"Invalid n value: number of blocks must be positive\n");
        return blocks;
    }
    if (map.n_chr < 1) {
        fprintf(stderr,"Map has no chromosomes, so it cannot be divided into blocks\n");
    }
 
    blocks.num_blocks = n * map.n_chr;
    blocks.num_markers_in_block = gsc_malloc_wrap(sizeof(*blocks.num_markers_in_block) * blocks.num_blocks,GSC_TRUE);
    blocks.markers_in_block = gsc_malloc_wrap(sizeof(*blocks.markers_in_block) * blocks.num_blocks,GSC_TRUE);
    for (GSC_ID_T i = 0; i < blocks.num_blocks; ++i) {
        blocks.num_markers_in_block[i] = 0;
        blocks.markers_in_block[i] = NULL;
    }
 
    GSC_CREATE_BUFFER(temp_markers_in_block, GSC_GENOLEN_T, 128);
 
    for (GSC_GENOLEN_T chr = 0; chr < map.n_chr; ++chr) {
        GSC_GENOLEN_T firstblockix = chr*n;
        GSC_GENOLEN_T blockix = firstblockix;
        
        switch (map.chrs[chr].type) {
        case GSC_LINKAGEGROUP_SIMPLE:
            if (map.chrs[chr].map.simple.n_markers == 1) {
                blocks.num_markers_in_block[firstblockix] = 1;
                blocks.markers_in_block[firstblockix] = gsc_malloc_wrap(sizeof(**blocks.markers_in_block), GSC_TRUE);
                blocks.markers_in_block[firstblockix][0] = map.chrs[chr].map.simple.first_marker_index;
            } else if (map.chrs[chr].map.simple.n_markers > 1) {
                // For floating point reasons we manually allocate first marker to first block
                blocks.num_markers_in_block[blockix] = 1;
                temp_markers_in_block[0] = map.chrs[chr].map.simple.first_marker_index;
                
                for (GSC_GENOLEN_T m = 1; m < map.chrs[chr].map.simple.n_markers; ++m) {
                    //RPACKINSERT R_CheckUserInterrupt();
                    
                    while (blockix - firstblockix < n-1 && 
                            map.chrs[chr].map.simple.dists[m] > (blockix - firstblockix + 1) / (float)n) {
                        // Save this block and move on to the next one.
                        if (blocks.num_markers_in_block[blockix] > 0) {
                            size_t bcapacity = sizeof(**blocks.markers_in_block) * blocks.num_markers_in_block[blockix];
                            blocks.markers_in_block[blockix] = gsc_malloc_wrap(bcapacity, GSC_TRUE);
                            memcpy(blocks.markers_in_block[blockix],temp_markers_in_block,bcapacity);
                        }
                        ++blockix;
                    }
                    
                    // Add this marker to the block.
                    int currentn = blocks.num_markers_in_block[blockix];
                    if (currentn >= temp_markers_in_blockcap) {
                        GSC_STRETCH_BUFFER(temp_markers_in_block,2*currentn);
                    }
                    temp_markers_in_block[currentn] = map.chrs[chr].map.simple.first_marker_index + m;
                    ++(blocks.num_markers_in_block[blockix]);
                }
                
                // Save last filled block
                if (blocks.num_markers_in_block[blockix] > 0) {
                    size_t bcapacity = sizeof(**blocks.markers_in_block) * blocks.num_markers_in_block[blockix];
                    blocks.markers_in_block[blockix] = gsc_malloc_wrap(bcapacity, GSC_TRUE);
                    memcpy(blocks.markers_in_block[blockix],temp_markers_in_block,bcapacity);
                }
            }
            break;
        
        case GSC_LINKAGEGROUP_REORDER:
            if (map.chrs[chr].map.reorder.n_markers == 1) {
                blocks.num_markers_in_block[firstblockix] = 1;
                blocks.markers_in_block[firstblockix] = gsc_malloc_wrap(sizeof(**blocks.markers_in_block), GSC_TRUE);
                blocks.markers_in_block[firstblockix][0] = map.chrs[chr].map.reorder.marker_indexes[0];
            } else if (map.chrs[chr].map.reorder.n_markers > 1) {
                // For floating point reasons we manually allocate first marker to first block
                blocks.num_markers_in_block[blockix] = 1;
                temp_markers_in_block[0] = map.chrs[chr].map.reorder.marker_indexes[0];
            
                for (GSC_GENOLEN_T m = 1; m < map.chrs[chr].map.reorder.n_markers; ++m) {
                    //RPACKINSERT R_CheckUserInterrupt();
                    
                    while (blockix - firstblockix < n-1 && 
                            map.chrs[chr].map.reorder.dists[m] > (blockix - firstblockix + 1) / (float)n) {
                        // Save this block and move on to the next one.
                        if (blocks.num_markers_in_block[blockix] > 0) {
                            size_t bcapacity = sizeof(**blocks.markers_in_block) * blocks.num_markers_in_block[blockix];
                            blocks.markers_in_block[blockix] = gsc_malloc_wrap(bcapacity, GSC_TRUE);
                            memcpy(blocks.markers_in_block[blockix],temp_markers_in_block,bcapacity);
                        }
                        ++blockix;
                    }
                    
                    // Add this marker to the block.
                    int currentn = blocks.num_markers_in_block[blockix];
                    if (currentn >= temp_markers_in_blockcap) {
                        GSC_STRETCH_BUFFER(temp_markers_in_block,2*currentn);
                    }
                    temp_markers_in_block[currentn] = map.chrs[chr].map.reorder.marker_indexes[m];
                    ++(blocks.num_markers_in_block[blockix]);
                }
                
                // Save last filled block
                if (blocks.num_markers_in_block[blockix] > 0) {
                    size_t bcapacity = sizeof(**blocks.markers_in_block) * blocks.num_markers_in_block[blockix];
                    blocks.markers_in_block[blockix] = gsc_malloc_wrap(bcapacity, GSC_TRUE);
                    memcpy(blocks.markers_in_block[blockix],temp_markers_in_block,bcapacity);
                }
            }
            break;
        }
    }
 
    GSC_DELETE_BUFFER(temp_markers_in_block);
 
    return blocks;
}
 
gsc_MarkerBlocks gsc_load_blocks(const gsc_SimData* d, const char* block_file) {
    struct gsc_TableSize ts = gsc_get_file_dimensions(block_file, '\t');
 
    gsc_MarkerBlocks blocks;
    blocks.num_blocks = ts.num_rows - 1;
    blocks.num_markers_in_block = gsc_malloc_wrap(sizeof(GSC_GENOLEN_T) * blocks.num_blocks,GSC_TRUE);
    blocks.markers_in_block = gsc_malloc_wrap(sizeof(GSC_GENOLEN_T*) * blocks.num_blocks,GSC_TRUE);
 
    FILE* infile;
    if ((infile = fopen(block_file, "r")) == NULL) {
        fprintf(stderr, "Failed to open file %s.\n", block_file); exit(1);
        //return blocks;
    }
 
    GSC_GENOLEN_T bufferlen = d->genome.n_markers;
    GSC_CREATE_BUFFER(markername,char,CONTIG_WIDTH);
    GSC_CREATE_BUFFER(markerbuffer,GSC_GENOLEN_T,bufferlen);
    GSC_ID_T bi = 0; // block number
 
    // Ignore the first line
    fscanf(infile, "%*[^\n]\n");
 
    // Loop through rows of the file (each row corresponds to a block)
    while (fscanf(infile, "%*d %*f %*s %*s ") != EOF) {
    //for (int bi = 0; bi < n_blocks; ++bi) {
 
        // Indexes in play:
        //      bi: index in the blocks struct's arrays of the current block/line in the file
        //      ni: number of characters so far in the name of the next marker being read from the file
        //      mi: number of markers that have so far been read from the file for this block
        blocks.num_markers_in_block[bi] = 0;
        int c;
        size_t ni = 0;
        GSC_GENOLEN_T mi = 0;
 
        memset(markerbuffer, 0, sizeof(*markerbuffer) * bufferlen);
        while ((c = fgetc(infile)) != EOF && c !='\n') {
            if (c == ';') {
                markername[ni] = '\0';
 
                // identify the index of this marker and save it in the temporary marker buffer `markerbuffer`
                GSC_GENOLEN_T markerindex; 
                if (gsc_get_index_of_genetic_marker(markername, d->genome, &markerindex)) {
                    ++(blocks.num_markers_in_block[bi]);
                    markerbuffer[mi] = markerindex;
                    ++mi;
                }
                                
                ni = 0;
            } else {
                markername[ni] = c;
                ++ni;
            }
        }
 
        // copy the markers belonging to this block into the struct
        blocks.markers_in_block[bi] = gsc_malloc_wrap(sizeof(GSC_GENOLEN_T) * mi,GSC_TRUE);
        for (GSC_GENOLEN_T i = 0; i < mi; ++i) {
            blocks.markers_in_block[bi][i] = markerbuffer[i];
        }
 
        ++bi;
    }
 
    GSC_DELETE_BUFFER(markerbuffer);
    GSC_DELETE_BUFFER(markername);
    fclose(infile);
    return blocks;
}
 
gsc_DecimalMatrix gsc_calculate_local_bvs(const gsc_SimData* d, 
                                                const gsc_GroupNum group,
                                                const gsc_MarkerBlocks b, 
                                                const gsc_EffectID effID) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        return gsc_generate_zero_dmatrix(0, 0);
    }
    gsc_MarkerEffects e = d->e[effIndex];
 
    // casing away const but I promise not to use the iterator to change anything
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, group);
    
    gsc_DecimalMatrix bvs = gsc_calculate_utility_local_bvs(&it, b, e);
 
    gsc_delete_bidirectional_iter(&it);
    return bvs;
}
 
gsc_DecimalMatrix gsc_calculate_utility_local_bvs(gsc_BidirectionalIterator* targets, 
                                                  gsc_MarkerBlocks b,
                                                  gsc_MarkerEffects e) {
    if (b.num_blocks == 0) {
        GSC_GENOLEN_T ntargets = 0;
        gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(targets);
        while (IS_VALID_LOCATION(loc)) {
            ++ntargets; loc = gsc_next_forwards(targets);
        }
        return gsc_generate_zero_dmatrix(2*ntargets, 0);
    }
    
    GSC_CREATE_BUFFER(bvs, double*, 50);
    GSC_GLOBALX_T n_genotypes = 0;
    
    gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(targets);
    if (e.centre == NULL) {
        // for each group member
        while (IS_VALID_LOCATION(loc)) {
            GSC_GLOBALX_T hap1 = 2*n_genotypes;
            GSC_GLOBALX_T hap2 = hap1 + 1;
            
            if (hap1 >= bvscap) {
                GSC_STRETCH_BUFFER(bvs, 2*hap1);
            }
            
            //RPACKINSERT R_CheckUserInterrupt();
            bvs[hap1] = gsc_malloc_wrap(sizeof(*bvs[hap1])*b.num_blocks, GSC_TRUE);
            bvs[hap2] = gsc_malloc_wrap(sizeof(*bvs[hap2])*b.num_blocks, GSC_TRUE);
            char* genotype = gsc_get_alleles(loc);
            
            // for each block
            for (GSC_ID_T j = 0; j < b.num_blocks; ++j) {
                //RPACKINSERT R_CheckUserInterrupt();
                bvs[hap1][j] = 0.;
                bvs[hap2][j] = 0.;
 
                // calculate the local BV
                for (GSC_GENOLEN_T k = 0; k < b.num_markers_in_block[j]; ++k) {
                    GSC_GENOLEN_T markerix = b.markers_in_block[j][k];
                    _Bool gotallele1 = 0;
                    _Bool gotallele2 = 0;
                    
                    for (GSC_GENOLEN_T eix = ((markerix > 0) ? e.cumn_alleles[markerix-1] : 0); 
                           eix < e.cumn_alleles[markerix]; ++eix) {         
                        if (!gotallele1 && e.allele[eix] == genotype[2*markerix]) { 
                            bvs[hap1][j] += e.eff[eix];
                            gotallele1 = 1;
                        }
                        if (!gotallele2 && e.allele[eix] == genotype[2*markerix + 1]) { 
                            bvs[hap2][j] += e.eff[eix];
                            gotallele2 = 1;
                        }
                    }
                }
            }
            
            ++n_genotypes;
            loc = gsc_next_forwards(targets);
        }
    } else { // adding centering in a separate branch for theoretical performance re branching
        while (IS_VALID_LOCATION(loc)) {
            GSC_GLOBALX_T hap1 = 2*n_genotypes;
            GSC_GLOBALX_T hap2 = hap1 + 1;
            
            if (hap1 >= bvscap) {
                GSC_STRETCH_BUFFER(bvs, 2*hap1);
            }
            
            bvs[hap1] = gsc_malloc_wrap(sizeof(*bvs[hap1])*b.num_blocks, GSC_TRUE);
            bvs[hap2] = gsc_malloc_wrap(sizeof(*bvs[hap2])*b.num_blocks, GSC_TRUE);
            char* genotype = gsc_get_alleles(loc);
            
            // for each block
            for (GSC_ID_T j = 0; j < b.num_blocks; ++j) {
                //RPACKINSERT R_CheckUserInterrupt();
                bvs[hap1][j] = 0.;
                bvs[hap2][j] = 0.;
 
                // calculate the local BV
                for (GSC_GENOLEN_T k = 0; k < b.num_markers_in_block[j]; ++k) {
                    GSC_GENOLEN_T markerix = b.markers_in_block[j][k];
                    _Bool gotallele1 = 0;
                    _Bool gotallele2 = 0;
                    
                    for (GSC_GENOLEN_T eix = ((markerix > 0) ? e.cumn_alleles[markerix-1] : 0); 
                           eix < e.cumn_alleles[markerix]; ++eix) { 
                        if (!gotallele1 && e.allele[eix] == genotype[2*markerix]) { 
                            bvs[hap1][j] += e.eff[eix];
                            gotallele1 = 1;
                        }
                        if (!gotallele2 && e.allele[eix] == genotype[2*markerix + 1]) { 
                            bvs[hap2][j] += e.eff[eix];
                            gotallele2 = 1;
                        }
                    }
                    bvs[hap1][j] -= e.centre[markerix];
                    bvs[hap2][j] -= e.centre[markerix];
                }
            }
            
            ++n_genotypes;
            loc = gsc_next_forwards(targets);
        }       
    } 
 
    gsc_DecimalMatrix out;
    GSC_FINALISE_BUFFER(bvs,out.matrix,2*n_genotypes);
    out.dim1 = 2*n_genotypes;
    out.dim2 = b.num_blocks;
    return out;
}
 
void gsc_calculate_optimal_haplotype(const gsc_SimData* d, 
                                      const gsc_EffectID effID, 
                                      const char symbol_na,
                                      char* opt_haplotype) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        memset(opt_haplotype, 0, sizeof(char)*(d->genome.n_markers + 1));
        return;
    }
    gsc_MarkerEffects e = d->e[effIndex];
 
    for (GSC_GENOLEN_T m_ix = 0; m_ix < d->genome.n_markers; ++m_ix) {
        char best_allele;
        double best_score;
        GSC_GENOLEN_T e_ix = (m_ix > 0) ? e.cumn_alleles[m_ix-1] : 0;
        if (e_ix >= e.cumn_alleles[m_ix]) {
            // we have no marker effects for alleles at this marker
            best_allele = symbol_na;
        } else { // do have marker effects. initialise the max.
            best_allele = e.allele[e_ix];
            best_score = e.eff[e_ix];
            ++ e_ix;
        }
        for (; e_ix < e.cumn_alleles[m_ix]; ++e_ix) {
            if (e.eff[e_ix] > best_score) {
                best_score = e.eff[e_ix];
                best_allele = e.allele[e_ix];
            }
        }           
        
        opt_haplotype[m_ix] = best_allele;
    }
    opt_haplotype[d->genome.n_markers] = '\0';
}
 
 
void gsc_calculate_optimal_possible_haplotype(const gsc_SimData* d, 
                                               const gsc_GroupNum group, 
                                               const gsc_EffectID effID,
                                               const char symbol_na,
                                               char* opt_haplotype) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        memset(opt_haplotype, 0, sizeof(char)*(d->genome.n_markers + 1));
        return;
    }
    gsc_MarkerEffects e = d->e[effIndex];
    
    GSC_CREATE_BUFFER(checked,_Bool,e.cumn_alleles[e.n_markers-1]);
    memset(checked, 0, sizeof(_Bool)*e.cumn_alleles[e.n_markers-1]);
    
    GSC_CREATE_BUFFER(best_score,double,d->genome.n_markers);
    for (GSC_GENOLEN_T m = 0; m < d->genome.n_markers; ++m) {
        best_score[m] = NAN;
        opt_haplotype[m] = symbol_na;
    }
    
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, group);
    gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(&it);
    while (IS_VALID_LOCATION(loc)) {
        char* genotype = gsc_get_alleles(loc);
        // Loop through markers
        for (GSC_GENOLEN_T m = 0; m < d->genome.n_markers; ++m) {
            // Loop through alleles at that marker
            for (GSC_GENOLEN_T e_ix = ((m > 0) ? e.cumn_alleles[m-1] : 0); 
                    e_ix < e.cumn_alleles[m]; ++e_ix) {
                if (!checked[e_ix] && (genotype[2*m] == e.allele[e_ix] || 
                                       genotype[2*m+1] == e.allele[e_ix])) {
                    // Let's check if this allele is better
                    double score = 2 * e.eff[e_ix];
                    if (isnan(best_score[m]) || score > best_score[m]) {
                        best_score[m] = score;
                        opt_haplotype[m] = e.allele[e_ix];
                    }
                    checked[e_ix] = 1;
                }
            }
        }
        loc = gsc_next_forwards(&it);
    }
    
    gsc_delete_bidirectional_iter(&it);
    GSC_DELETE_BUFFER(checked);
    GSC_DELETE_BUFFER(best_score);
    
    opt_haplotype[d->genome.n_markers] = '\0';
}
 
 
double gsc_calculate_optimal_bv(const gsc_SimData* d, const gsc_EffectID effID) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        return 0;
    }
    gsc_MarkerEffects e = d->e[effIndex];
    
    double best_gebv = 0.;
    for (GSC_GENOLEN_T m_ix = 0; m_ix < e.n_markers; ++m_ix) {
        double best_score = 0;
        GSC_GENOLEN_T e_ix = (m_ix > 0) ? e.cumn_alleles[m_ix-1] : 0;
        if (e_ix < e.cumn_alleles[m_ix]) { // we have marker effects for this marker. initialise
            best_score = e.eff[e_ix];
            ++e_ix;
        }
        for (; e_ix < e.cumn_alleles[m_ix]; ++e_ix) {
            if (e.eff[e_ix] > best_score) {
                best_score = e.eff[e_ix];
            }
        }           
        
        best_gebv += (2*best_score);
    }
    
    if (e.centre != NULL) {
        double summedcentres = 0.;
        for (GSC_GENOLEN_T m = 0; m < e.n_markers; ++m) {
            summedcentres += e.centre[m];
        }
        best_gebv -= summedcentres;
    }
 
    return best_gebv;
}
 
double gsc_calculate_optimal_possible_bv(const gsc_SimData* d, 
                                         const gsc_GroupNum group, 
                                         const gsc_EffectID effID) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        return 0;
    }
    gsc_MarkerEffects e = d->e[effIndex];
    
    GSC_CREATE_BUFFER(checked,_Bool,e.cumn_alleles[e.n_markers-1]);
    memset(checked, 0, sizeof(_Bool)*e.cumn_alleles[e.n_markers-1]);
    
    GSC_CREATE_BUFFER(best_score,double,d->genome.n_markers);
    for (GSC_GENOLEN_T m = 0; m < d->genome.n_markers; ++m) {
        best_score[m] = NAN;
    }
    
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, group);
    gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(&it);
    while (IS_VALID_LOCATION(loc)) {
        char* genotype = gsc_get_alleles(loc);
        // Loop through markers
        for (GSC_GENOLEN_T m = 0; m < e.n_markers; ++m) {
            // Loop through alleles at that marker
            for (GSC_GENOLEN_T e_ix = ((m > 0) ? e.cumn_alleles[m-1] : 0); 
                    e_ix < e.cumn_alleles[m]; ++e_ix) {
                if (!checked[e_ix] && (genotype[2*m] == e.allele[e_ix] || 
                                       genotype[2*m+1] == e.allele[e_ix])) {
                    // Let's check if this allele is better
                    double score = 2 * e.eff[e_ix];
                    if (isnan(best_score[m]) || score > best_score[m]) {
                        best_score[m] = score;
                    }
                    checked[e_ix] = 1;
                }
            }
        }
        loc = gsc_next_forwards(&it);
    }
    
    // sum up at the end
    double optimal_bv = 0; 
    for (GSC_GENOLEN_T m = 0; m < e.n_markers; ++m) {
        if (!isnan(best_score[m])) {
            optimal_bv += best_score[m];
        }
    }
    
    if (e.centre != NULL) {
        double summedcentres = 0.;
        for (GSC_GENOLEN_T m = 0; m < e.n_markers; ++m) {
            summedcentres += e.centre[m];
        }
        optimal_bv -= summedcentres;
    }
    
    gsc_delete_bidirectional_iter(&it);
    GSC_DELETE_BUFFER(checked);
    GSC_DELETE_BUFFER(best_score);
    return optimal_bv;
}
 
double gsc_calculate_minimal_bv(const gsc_SimData* d, const gsc_EffectID effID) {
    const GSC_ID_T effIndex = gsc_get_index_of_eff_set(d, effID);
    if (effIndex == GSC_NA_IDX) {
        fprintf(stderr,"Nonexistent effect set with id %lu\n", (long unsigned int) effID.id);
        return 0;
    }
    gsc_MarkerEffects e = d->e[effIndex];
    
    double worst_gebv = 0.;
    for (GSC_GENOLEN_T m_ix = 0; m_ix < e.n_markers; ++m_ix) {
        double worst_score = 0;
        GSC_GENOLEN_T e_ix = (m_ix > 0) ? e.cumn_alleles[m_ix-1] : 0;
        if (e_ix < e.cumn_alleles[m_ix]) { // we have marker effects for this marker. initialise
            worst_score = e.eff[e_ix];
            ++e_ix;
        }
        for (; e_ix < e.cumn_alleles[m_ix]; ++e_ix) {
            if (e.eff[e_ix] < worst_score) {
                worst_score = e.eff[e_ix];
            }
        }           
        
        worst_gebv += (2*worst_score);
    }
    
    if (e.centre != NULL) {
        double summedcentres = 0.;
        for (GSC_GENOLEN_T m = 0; m < e.n_markers; ++m) {
            summedcentres += e.centre[m];
        }
        worst_gebv -= summedcentres;
    }
 
    return worst_gebv;
}
 
/*--------------------------------Saving-----------------------------------*/
 
void gsc_save_markerblocks(const char* fname, 
                           const gsc_SimData* d, 
                           const gsc_MarkerBlocks b, 
                           const gsc_MapID labelMapID) {
    FILE* f;
    if ((f = fopen(fname, "w")) == NULL) {
        fprintf(stderr, "Failed to open file %s for writing output\n", fname); return;
    }
 
    GSC_ID_T mapix;
    if (labelMapID.id == NO_MAP.id || (mapix = gsc_get_index_of_map(d, labelMapID)) == GSC_NA_IDX) {
        gsc_save_utility_markerblocks(f, b, d->genome.n_markers, d->genome.marker_names, NULL);
    } else {
        gsc_save_utility_markerblocks(f, b, d->genome.n_markers, d->genome.marker_names, &d->genome.maps[mapix]);
    }
}
 
void gsc_save_genotypes(const char* fname, 
                        const gsc_SimData* d, 
                        const gsc_GroupNum groupID, 
                        const _Bool markers_as_rows) {
    FILE* f;
    if ((f = fopen(fname, "w")) == NULL) {
        fprintf(stderr, "Failed to open file %s for writing output\n", fname); return;
    }
 
    // casing away const but I promise not to use the iterator to change anything
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, groupID);
 
    gsc_save_utility_genotypes(f, &it, d->genome.n_markers, d->genome.marker_names, markers_as_rows);
 
    delete_bidirectional_iter(&it);
    fclose(f);
}
 
void gsc_save_allele_counts(const char* fname, 
                            const gsc_SimData* d, 
                            const gsc_GroupNum groupID, 
                            const char allele, 
                            const _Bool markers_as_rows) {
    FILE* f;
    if ((f = fopen(fname, "w")) == NULL) {
        fprintf(stderr, "Failed to open file %s for writing output\n", fname); return;
    }
 
    // casing away const but I promise not to use the iterator to change anything
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, groupID);
 
    gsc_save_utility_allele_counts(f, &it, d->genome.n_markers, d->genome.marker_names, 
                                   markers_as_rows, allele);
 
    delete_bidirectional_iter(&it);
    fclose(f);
}
 
void gsc_save_pedigrees(const char* fname, 
                        const gsc_SimData* d,
                        const gsc_GroupNum groupID, 
                        const _Bool full_pedigree) { 
    FILE* f;
    if ((f = fopen(fname, "w")) == NULL) {
        fprintf(stderr, "Failed to open file %s for writing output\n", fname); return;
    }
 
    // casing away const but I promise not to use the iterator to change anything
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, groupID);
 
    gsc_save_utility_pedigrees(f, &it, full_pedigree, d->m);
 
    delete_bidirectional_iter(&it);
    fclose(f);
}
 
void gsc_save_bvs(const char* fname, 
                  const gsc_SimData* d, 
                  const gsc_GroupNum groupID, 
                  const gsc_EffectID effID) {
    FILE* f;
    if ((f = fopen(fname, "w")) == NULL) {
        fprintf(stderr, "Failed to open file %s for writing output\n", fname); return;
    }
 
    GSC_ID_T effix = gsc_get_index_of_eff_set(d, effID);
    if (effix == GSC_NA_IDX) {
        fprintf(stderr, "Marker effect set %lu does not exist: cannot calculate breeding values\n", (long unsigned int) effID.id); return;
    }
 
    // casting away const but I promise not to use the iterator to change anything
    gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, groupID);
 
    gsc_save_utility_bvs(f, &it, &d->e[effix]);
 
    delete_bidirectional_iter(&it);
    fclose(f);
}
 
void gsc_save_local_bvs(const char* fname, 
                        const gsc_SimData* d, 
                        const gsc_GroupNum groupID, 
                        const gsc_MarkerBlocks b,
                        const gsc_EffectID effID, 
                        const _Bool headers) {
    FILE* f;
    if ((f = fopen(fname, "w")) == NULL) {
        fprintf(stderr, "Failed to open file %s for writing output\n", fname); return;
    }
 
    gsc_DecimalMatrix dec = gsc_calculate_local_bvs(d, groupID, b, effID);
 
    if (headers) {
        // Re: headers:
        // 1. rows shall be genotype names with _1 or _2 appended
        // 2. blocks don't have names right now. They shall remain nameless.
        GSC_CREATE_BUFFER(ghapnames,char*,dec.dim1);
        GSC_GLOBALX_T i = 0;
        // casting away const but I promise not to use the iterator to change anything
        gsc_BidirectionalIterator it = gsc_create_bidirectional_iter((gsc_SimData*) d, groupID);
        gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(&it);
        while (IS_VALID_LOCATION(loc)) {
            char* name = gsc_get_name(loc);
            int len = (name == NULL) ? 0 : strlen(name); // if name is null, the header will just be "_1" and "_2".
            ghapnames[i] = gsc_malloc_wrap(sizeof(char)*(len+3), GSC_TRUE);
            ghapnames[i+1] = gsc_malloc_wrap(sizeof(char)*(len+3), GSC_TRUE);
 
            strncpy(ghapnames[i], name, sizeof(char)*len);
            ghapnames[i][len] = '_'; ghapnames[i][len+1] = '1'; ghapnames[i][len+2] = '\0';
            strncpy(ghapnames[i+1], name, sizeof(char)*len);
            ghapnames[i+1][len] = '_'; ghapnames[i+1][len+1] = '2'; ghapnames[i+1][len+2] = '\0';
 
            i += 2;
            if (i >= dec.dim1) {
                break;
            }
 
            loc = gsc_next_forwards(&it);
        }
        for (; i < dec.dim1; ++i) { // zero trailing entries if something went wrong.
            ghapnames[i] = NULL;
        }
        gsc_save_utility_dmatrix(f, &dec, ghapnames, NULL, 0);
        for (size_t i = 0; i < dec.dim1; ++i) {
            if (ghapnames[i] != NULL) {
                GSC_FREE(ghapnames[i]);
            }
        }
        GSC_DELETE_BUFFER(ghapnames);
    } else {
        gsc_save_utility_dmatrix(f, &dec, NULL, NULL, 0);
    }
 
    gsc_delete_dmatrix(&dec);
    fclose(f);
}
 
static GSC_LOGICVAL gsc_helper_is_marker_in_chr(const GSC_GENOLEN_T markerix, 
                                                const gsc_LinkageGroup chr, 
                                                double* pos) {
    GSC_GENOLEN_T offset;
    switch (chr.type) {
        case GSC_LINKAGEGROUP_SIMPLE:
            offset = markerix - chr.map.simple.first_marker_index;
            if (offset >= 0 && offset < chr.map.simple.n_markers) {
               if (pos != NULL && chr.map.simple.n_markers > 1) {
                   *pos = chr.map.simple.dists[offset] * chr.map.simple.expected_n_crossovers;
               } else {
                   *pos = 0; // if there is only one marker on chromosome
               }
               return GSC_TRUE; 
            } else {
                return GSC_FALSE;
            }
        case GSC_LINKAGEGROUP_REORDER:
            for (GSC_GENOLEN_T i = 0; i < chr.map.reorder.n_markers; ++i) {
                if (markerix == chr.map.reorder.marker_indexes[i]) {
                    if (pos != NULL) {
                        *pos = chr.map.reorder.dists[i] * chr.map.reorder.expected_n_crossovers;
                    }
                    return GSC_TRUE;
                }
            }
            return GSC_FALSE;
    }
    return GSC_NA;
}
 
void gsc_save_utility_markerblocks(FILE* f, 
                                   const gsc_MarkerBlocks b, 
                                   const GSC_GENOLEN_T n_markers, 
                                   char** const marker_names, 
                                   const RecombinationMap* map) {
 
    // Header only gets printed if there are multiple columns. 
    // (If no map is provided, we print only the third column (markers in each block))
    if (map != NULL) {
        const char header[] = "Chrom\tLen\tMarkers\n";
        fwrite(header, sizeof(char)*strlen(header), 1, f);
    }
 
    for (GSC_ID_T i = 0; i < b.num_blocks; ++i) {
        if (map != NULL) {
            // If we are provided a map, then try to find and print the length of each block
            int isonchr = -1;
            double len = 0;
            if (b.num_markers_in_block[i] > 0) {
                double minpos = 0;
                double maxpos = 0;
                for (GSC_GENOLEN_T chrix = 0; chrix < map->n_chr; ++chrix) {
                    if (gsc_helper_is_marker_in_chr(b.markers_in_block[i][0],
                                                        map->chrs[chrix],&minpos)) {
                        isonchr = chrix;
                        maxpos = minpos;
                        for (GSC_GENOLEN_T j = 1; j < b.num_markers_in_block[i]; ++j) {
                            double pos;
                            if (gsc_helper_is_marker_in_chr(b.markers_in_block[i][j],
                                                        map->chrs[chrix],&pos)) {
                                maxpos = (pos > maxpos) ? pos : maxpos;
                                minpos = (pos < minpos) ? pos : minpos;
                            } else {
                                isonchr = -1;
                                break;
                            }
                        }
                        len = maxpos - minpos;
                        break;
                    }
                }
            }
 
            if (isonchr >= 0) {
                fprintf(f,"%lu\t%lf\t",(long unsigned int)isonchr,len*100);
            } else {
                const char colns[] = "-\t-\t";
                fwrite(colns, sizeof(char)*strlen(colns), 1, f);
            }
        }
 
        // Print the markers contained in the block
        for (GSC_GENOLEN_T j = 0; j < b.num_markers_in_block[i]; ++j) {
            GSC_GENOLEN_T k = b.markers_in_block[i][j];
            if (k <= n_markers) {
                fwrite(marker_names[k], sizeof(char)*strlen(marker_names[k]), 1, f);
            } else {
                fprintf(f,"%lu",(long unsigned int)k);
            }
            fputc(';',f);
        }
 
        fwrite("\n", sizeof(char), 1, f);
    }
    
    fflush(f);
    return;
}
 
static void gsc_scaffold_save_genotype_info(FILE* f, 
                                            gsc_BidirectionalIterator* targets, 
                                            GSC_GENOLEN_T n_markers, 
                                            char** const marker_names, 
                                            const _Bool markers_as_rows,
                                            void (*bodycell_printer)(FILE*, 
                                                                     gsc_GenoLocation, 
                                                                     GSC_GENOLEN_T, 
                                                                     void*),
                                            void* bodycell_printer_data) {
 
    // legacy feature: if printing a specific group's members, put the group number in 
    //                 the top left corner cell
    if (targets != NULL && targets->group.num != NO_GROUP.num) {
        fprintf(f,"%lu",(long unsigned int) targets->group.num);
    }
 
    GSC_GLOBALX_T ntargets;
    if (markers_as_rows) {
        ntargets = 0;
        // Header row (genotype names)
        if (targets != NULL) {
            gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(targets);
            while (IS_VALID_LOCATION(loc)) {
                fwrite("\t", sizeof(char), 1, f);
                ++ntargets;
                char* n = gsc_get_name(loc);
                if (n != NULL) {
                    fwrite(n, sizeof(char)*strlen(n), 1, f);
                } else {
                    fprintf(f, "%lu", (long unsigned int) gsc_get_id(loc).id);
                }
                   
                loc = gsc_next_forwards(targets);
            }
            fwrite("\n", sizeof(char), 1, f);
        }
 
        // Body (genotypes and genotype names)
        // - This is our row counter 
        GSC_GENOLEN_T row = 0;
        gsc_GenoLocation* genos = NULL;
        // - This is our genotype position cache, because BidirectionalIterator does not have a built-in cache
        if (ntargets > 0 && ((row < n_markers || (ntargets > 0 && row < targets->cachedAM->n_markers)))) {
            genos = gsc_malloc_wrap(sizeof(*genos)*ntargets, GSC_FALSE);
            if (genos != NULL) {
                genos[0] = gsc_set_bidirectional_iter_to_start(targets);
                for (GSC_GLOBALX_T i = 1; i < ntargets; ++i) { 
                    genos[i] = gsc_next_forwards(targets); 
                }
            }
        }
        while (row < n_markers || (ntargets > 0 && row < targets->cachedAM->n_markers)) {
            // Row header
            if (row < n_markers) {
                if (marker_names[row] != NULL) {
                    fwrite(marker_names[row], sizeof(char)*strlen(marker_names[row]), 1, f);
                }
            }
 
            // Row body
            for (GSC_GLOBALX_T i = 0; i < ntargets; ++i) {
                gsc_GenoLocation loc;
                if (genos != NULL) {
                    loc = genos[i];
                } else {
                    loc = (i == 0) ? gsc_set_bidirectional_iter_to_start(targets) : 
                                     gsc_next_forwards(targets);
                }
 
                fwrite("\t", sizeof(char), 1, f);
                bodycell_printer(f,loc,row,bodycell_printer_data);
            }
               
            fwrite("\n", sizeof(char), 1, f);
            ++row;
        }
        if (genos != NULL) { GSC_FREE(genos); }
 
    } else { // markers as rows = false 
        // Header row (marker names)
        if (marker_names != NULL) {
            for (GSC_GENOLEN_T i = 0; i < n_markers; ++i) {
                fwrite("\t", sizeof(char), 1, f);
                if (marker_names[i] != NULL) {
                    fwrite(marker_names[i], sizeof(char)*strlen(marker_names[i]), 1, f);
                }
            }
            fwrite("\n", sizeof(char), 1, f);
        }
 
        // Body (genotypes and genotype names)
        if (targets != NULL) {
            gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(targets);
            while (IS_VALID_LOCATION(loc)) {
                // Row header
                char* n = gsc_get_name(loc);
                if (n != NULL) {
                    fwrite(n, sizeof(char)*strlen(n), 1, f);
                } else {
                    fprintf(f, "%lu", (long unsigned int) gsc_get_id(loc).id);
                }
 
                // Row body
                for (GSC_GENOLEN_T i = 0; i < targets->cachedAM->n_markers; ++i) {
                    fwrite("\t", sizeof(char), 1, f);
                    bodycell_printer(f,loc,i,bodycell_printer_data);
                }
                fwrite("\n", sizeof(char), 1, f);
 
                loc = gsc_next_forwards(targets);
            }
        }             
    }
 
    fflush(f);
    return;  
}
 
static void gsc_helper_output_genotypematrix_cell(FILE* f, 
                                                  gsc_GenoLocation loc, 
                                                  GSC_GENOLEN_T markerix, 
                                                  void* NA) {
    if (IS_VALID_LOCATION(loc)) {
        fwrite(gsc_get_alleles(loc) + 2*markerix, sizeof(char)*2, 1, f);
    }
}
 
static void gsc_helper_output_countmatrix_cell(FILE* f, 
                                               gsc_GenoLocation loc, 
                                               GSC_GENOLEN_T markerix, 
                                               void* data) {
    if (IS_VALID_LOCATION(loc)) {
        char allele = *(char*) data;
        int count = 0;
        if (get_alleles(loc)[2*markerix] == allele)     { ++count; }
        if (get_alleles(loc)[2*markerix + 1] == allele) { ++count; }
        char out = '0' + count;
        fwrite(&out, sizeof(char), 1, f);
    }
}
 
void gsc_save_utility_genotypes(FILE* f, 
                                gsc_BidirectionalIterator* targets, 
                                GSC_GENOLEN_T n_markers, 
                                char** const marker_names, 
                                const _Bool markers_as_rows) {
    gsc_scaffold_save_genotype_info(f, targets, n_markers, marker_names, markers_as_rows, 
        &gsc_helper_output_genotypematrix_cell, NULL);
}
 
void gsc_save_utility_allele_counts(FILE* f, 
                                    gsc_BidirectionalIterator* targets,
                                    GSC_GENOLEN_T n_markers, 
                                    char** const marker_names, 
                                    const _Bool markers_as_rows, 
                                    const char allele) {
    gsc_scaffold_save_genotype_info(f, targets, n_markers, marker_names, markers_as_rows, 
            &gsc_helper_output_countmatrix_cell, (void*)&allele); 
}
 
static void gsc_scaffold_save_ancestry_of(const gsc_AlleleMatrix* m, 
                                          gsc_PedigreeID p1, 
                                          gsc_PedigreeID p2,
                                          void (*strprinter)(char*, size_t, void*), 
                                          void (*intprinter)(long unsigned int, void*), 
                                          void* printer_data) {
    gsc_PedigreeID pedigree[2];
 
    // open brackets
    strprinter("=(", sizeof(char)*2,printer_data); 
    char* name;
 
    // enables us to print only the known parent if one is unknown
    if (p1.id == GSC_NO_PEDIGREE.id || p2.id == GSC_NO_PEDIGREE.id) {
        p1.id = (p1.id >= p2.id) ? p1.id : p2.id; //max of the two
        p2.id = p1.id;
    }
 
    if (p1.id == p2.id) {
        if (p1.id != GSC_NO_PEDIGREE.id) { //print nothing if both are unknown.
            // Selfed parent
            name = gsc_get_name_of_id( m, p1);
            if (name != NULL) {
                strprinter(name, sizeof(char)*strlen(name), printer_data); 
            } else if (p1.id != GSC_NO_PEDIGREE.id) {
                intprinter((long unsigned int) p1.id,printer_data);
            }
 
            if (gsc_get_parents_of_id(m, p1, pedigree) == 0) {
                gsc_scaffold_save_ancestry_of(m, pedigree[0], pedigree[1],strprinter,intprinter,printer_data);
            }
        }
    } else {
        // Parent 1
        name = gsc_get_name_of_id( m, p1);
        if (name != NULL) {
            strprinter(name, sizeof(char)*strlen(name),printer_data); 
        } else if (p1.id != GSC_NO_PEDIGREE.id) {
            intprinter((long unsigned int) p1.id,printer_data);
        }
        if (gsc_get_parents_of_id(m, p1, pedigree) == 0) {
            gsc_scaffold_save_ancestry_of(m, pedigree[0], pedigree[1],strprinter,intprinter,printer_data);
        }
 
        // separator
        strprinter(",", sizeof(char),printer_data); 
 
        // Parent 2
        name = gsc_get_name_of_id( m, p2);
        if (name != NULL) {
            strprinter(name, sizeof(char)*strlen(name),printer_data); 
        } else if (p2.id != GSC_NO_PEDIGREE.id) {
            intprinter((long unsigned int) p2.id,printer_data);
        }
 
        if (gsc_get_parents_of_id(m, p2, pedigree) == 0) {
            gsc_scaffold_save_ancestry_of(m, pedigree[0], pedigree[1],strprinter,intprinter,printer_data);
        }
 
    }
 
    // close brackets
    strprinter(")", sizeof(char),printer_data); 
}
 
static void gsc_helper_ancestry_strprinter_file(char* str, size_t strlen, void* data) {
    FILE* f = (FILE*) data;
    fwrite(str, strlen, 1, f);
}
 
static void gsc_helper_ancestry_intprinter_file(long unsigned int i, void* data) {
    FILE* f = (FILE*) data;
    fprintf(f, "%lu", i);
}
 
void gsc_save_utility_pedigrees(FILE* f, 
                                gsc_BidirectionalIterator* targets,
                                const _Bool full_pedigree, 
                                const AlleleMatrix* parent_pedigree_store) {
 
    if (targets == NULL) { return; }
 
    gsc_GenoLocation loc;
    switch (full_pedigree) {
        case 0:
            loc = gsc_set_bidirectional_iter_to_start(targets);
            while (IS_VALID_LOCATION(loc)) {
                // Offspring
                char* n = gsc_get_name(loc);
                if (n != NULL) {
                    fwrite(n, sizeof(char)*strlen(n), 1, f);
                } else {
                    fprintf(f, "%lu", (long unsigned int) gsc_get_id(loc).id);
                }
 
                // Parents
                for (int parent = 0; parent < 2; ++parent) {
                    fwrite("\t", sizeof(char), 1, f);
                    n = NULL;
                    gsc_PedigreeID p = (parent == 0) ? gsc_get_first_parent(loc) : gsc_get_second_parent(loc);
                    if (p.id != GSC_NO_PEDIGREE.id && parent_pedigree_store != NULL) {
                        n = gsc_get_name_of_id(parent_pedigree_store, p);
                    }
                    if (n != NULL) {
                        fwrite(n, sizeof(char)*strlen(n), 1, f);
                    } else if (p.id != NO_PEDIGREE.id) {
                        fprintf(f, "%lu", (long unsigned int) p.id);
                    } 
                }
                
                fwrite("\n", sizeof(char), 1, f);
                loc = gsc_next_forwards(targets);
            }
            
            break;
        case 1:
            loc = gsc_set_bidirectional_iter_to_start(targets);
            while (IS_VALID_LOCATION(loc)) {
                // Offspring
                fprintf(f, "%lu\t", (long unsigned int) gsc_get_id(loc).id);
                char* n = gsc_get_name(loc);
                if (n != NULL) {
                    fwrite(n, sizeof(char)*strlen(n), 1, f);
                } 
 
                // Parents (recursively)
                if ((gsc_get_first_parent(loc).id != GSC_NO_PEDIGREE.id || 
                        gsc_get_second_parent(loc).id != GSC_NO_PEDIGREE.id) 
                        && parent_pedigree_store != NULL) {
                    gsc_scaffold_save_ancestry_of(parent_pedigree_store, 
                                gsc_get_first_parent(loc), gsc_get_second_parent(loc),
                                gsc_helper_ancestry_strprinter_file, gsc_helper_ancestry_intprinter_file, (void*) f); 
                }
                
                fwrite("\n", sizeof(char), 1, f);
                loc = gsc_next_forwards(targets);
            }
            
            break;
    }
 
    fflush(f);
    return;
}
 
void gsc_save_utility_bvs(FILE* f, 
                          gsc_BidirectionalIterator* targets, 
                          const gsc_MarkerEffects* eff) {
    if (targets == NULL || eff == NULL) { return; }
 
    gsc_DecimalMatrix bvs = gsc_calculate_utility_bvs(targets, eff);
    gsc_GenoLocation loc = gsc_set_bidirectional_iter_to_start(targets);
 
    for (size_t i = 0; i < bvs.dim2; ++i) {
        if (IS_VALID_LOCATION(loc)) {
            fprintf(f, "%lu", (long unsigned int) gsc_get_id(loc).id);
            fwrite("\t", sizeof(char), 1, f);
            char* n = gsc_get_name(loc);
            if (n != NULL) {
                fwrite(n, sizeof(char), strlen(n), f);
            }
            fwrite("\t", sizeof(char), 1, f);
        } else {
            fwrite("\t\t", sizeof(char)*2, 1, f);
        }
 
        fprintf(f, "%lf", bvs.matrix[0][i]);
        fwrite("\n", sizeof(char), 1, f);
 
        loc = gsc_next_forwards(targets);
    }
 
    gsc_delete_dmatrix(&bvs);
    fflush(f);
    return;
}
 
void gsc_save_utility_dmatrix(FILE* f,
                              DecimalMatrix* dec,
                              char** row_headers,
                              char** col_headers,
                              _Bool dim1_is_columns) {
    if (dec == NULL || dec->dim1 == 0 || dec->dim2 == 0) { return; }
    
    if (col_headers) {
        size_t ncols = (dim1_is_columns) ? dec->dim1 : dec->dim2;
        fwrite(col_headers[0], sizeof(char), strlen(col_headers[0]), f);
        for (size_t col = 1; col < ncols; ++col) {
            fwrite("\t", sizeof(char), 1, f);
            fwrite(col_headers[col], sizeof(char), strlen(col_headers[col]), f);
        }
        fwrite("\n", sizeof(char), 1, f);
    }
 
    if (dim1_is_columns) {
        for (size_t row = 0; row < dec->dim2; ++row) {
            if (row_headers) {
                fwrite(row_headers[row], sizeof(char), strlen(row_headers[row]), f);
                fwrite("\t", sizeof(char), 1, f);
            }
            
            fprintf(f,"%lf",dec->matrix[0][row]);
            for (size_t col = 1; col < dec->dim1; ++col) {
                fwrite("\t", sizeof(char), 1, f);
                fprintf(f,"%lf",dec->matrix[col][row]);
            }
            fwrite("\n", sizeof(char), 1, f);
        }
    } else {
        for (size_t row = 0; row < dec->dim1; ++row) {
            if (row_headers) {
                fwrite(row_headers[row], sizeof(char), strlen(row_headers[row]), f);
                fwrite("\t", sizeof(char), 1, f);
            }
            
            fprintf(f,"%lf",dec->matrix[row][0]);
            for (size_t col = 1; col < dec->dim2; ++col) {
                fwrite("\t", sizeof(char), 1, f);
                fprintf(f,"%lf",dec->matrix[row][col]);
            }
            fwrite("\n", sizeof(char), 1, f);
        }
    }
    
    fflush(f);
    return;
}
 
 
#endif