// Define color division for numbers
typedef enum {
    COLOR_WHITE = 0,     // Special case (1)
    COLOR_RED,           // Prime numbers
    COLOR_YELLOW,        // Divisible by 2 (even composites)
    COLOR_GREEN,         // Divisible by 3
    COLOR_BLUE,          // Divisible by 5
    COLOR_PURPLE,        // Divisible by 7
    COLOR_CYAN,          // Divisible by 11
    COLOR_ORANGE         // Other composites
} number_color_t;

// Determine color for a given number
number_color_t determineNumberColor(uint64_t number) {
    // Edge case: 1 is neither prime nor composite
    if (number == 1) {
        return COLOR_WHITE;
    }
    
    // Check if prime using optimized primality test
    if (isPrime(number)) {
        return COLOR_RED;
    }
    
    // Determine divisibility color
    if (number % 2 == 0) {
        return COLOR_YELLOW;
    } else if (number % 3 == 0) {
        return COLOR_GREEN;
    } else if (number % 5 == 0) {
        return COLOR_BLUE;
    } else if (number % 7 == 0) {
        return COLOR_PURPLE;
    } else if (number % 11 == 0) {
        return COLOR_CYAN;
    }
    
    // Other composites
    return COLOR_ORANGE;
}

// Apply chromatic transformation
void applyToPrimeChromatic(uint64_t* numbers, size_t count, 
                         chromatic_transform_t transform_type) {
    // Color map for transformation
    number_color_t* color_map = (number_color_t*)malloc(
        count * sizeof(number_color_t));
    
    // Determine colors for all numbers
    for (size_t i = 0; i < count; i++) {
        color_map[i] = determineNumberColor(numbers[i]);
    }
    
    // Apply transformation based on type
    switch (transform_type) {
        case TRANSFORM_PRIME_SHIFT:
            applyPrimeShiftTransform(numbers, color_map, count);
            break;
            
        case TRANSFORM_RESONANCE_AMPLIFY:
            applyResonanceAmplifyTransform(numbers, color_map, count);
            break;
            
        case TRANSFORM_HARMONIC_COLLAPSE:
            applyHarmonicCollapseTransform(numbers, color_map, count);
            break;
            
        case TRANSFORM_DIMENSIONAL_PROMOTE:
            applyDimensionalPromoteTransform(numbers, color_map, count);
            break;
    }
    
    // Free resources
    free(color_map);
}

// Define prime cluster structure
typedef struct {
    uint64_t start;          // Starting number of cluster
    uint64_t end;            // Ending number of cluster
    uint32_t prime_count;    // Number of primes in cluster
    double density;          // Density of primes in cluster
    double resonance_power;  // Calculated resonance power
} prime_cluster_t;

// Find prime clusters in number range
prime_cluster_t* findPrimeClusters(uint64_t min, uint64_t max, 
                                 double min_density, uint32_t* cluster_count) {
    // Initialize cluster array
    const uint32_t MAX_CLUSTERS = 1024;
    prime_cluster_t* clusters = (prime_cluster_t*)malloc(
        MAX_CLUSTERS * sizeof(prime_cluster_t));
    *cluster_count = 0;
    
    // Window for density calculation
    const uint32_t WINDOW_SIZE = 100;
    uint32_t primes_in_window = 0;
    
    // Sliding window to find clusters
    for (uint64_t start = min; start <= max - WINDOW_SIZE; start++) {
        // Count primes in current window
        primes_in_window = 0;
        for (uint64_t n = start; n < start + WINDOW_SIZE; n++) {
            if (isPrime(n)) {
                primes_in_window++;
            }
        }
        
        // Calculate density
        double density = (double)primes_in_window / WINDOW_SIZE;
        
        // If density meets threshold, record cluster
        if (density >= min_density && *cluster_count < MAX_CLUSTERS) {
            clusters[*cluster_count].start = start;
            clusters[*cluster_count].end = start + WINDOW_SIZE - 1;
            clusters[*cluster_count].prime_count = primes_in_window;
            clusters[*cluster_count].density = density;
            
            // Calculate resonance power based on cluster composition
            clusters[*cluster_count].resonance_power = 
                calculateClusterResonance(start, start + WINDOW_SIZE - 1);
            
            (*cluster_count)++;
        }
    }
    
    return clusters;
}

// Define harmonic interval types
typedef enum {
    INTERVAL_TWIN_PRIME,     // Consecutive primes with difference of 2
    INTERVAL_COUSIN_PRIME,   // Consecutive primes with difference of 4
    INTERVAL_SEXY_PRIME,     // Consecutive primes with difference of 6
    INTERVAL_FIBONACCI,      // Prime pairs matching Fibonacci intervals
    INTERVAL_PRIME_TRIPLET   // Three consecutive primes in close proximity
} harmonic_interval_t;

// Calculate harmonic score for a set of primes
double calculateHarmonicScore(uint64_t* primes, size_t count) {
    double score = 0.0;
    
    // Count different harmonic intervals
    uint32_t twin_count = 0;
    uint32_t cousin_count = 0;
    uint32_t sexy_count = 0;
    uint32_t fibonacci_count = 0;
    uint32_t triplet_count = 0;
    
    // Fibonacci numbers for interval checking
    const uint64_t fibonacci[] = {1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144};
    const size_t fib_count = sizeof(fibonacci) / sizeof(fibonacci[0]);
    
    // Check for interval patterns
    for (size_t i = 0; i < count - 1; i++) {
        uint64_t diff = primes[i+1] - primes[i];
        
        // Check for twin primes
        if (diff == 2) {
            twin_count++;
        }
        
        // Check for cousin primes
        if (diff == 4) {
            cousin_count++;
        }
        
        // Check for sexy primes
        if (diff == 6) {
            sexy_count++;
        }
        
        // Check for Fibonacci intervals
        for (size_t f = 0; f < fib_count; f++) {
            if (diff == fibonacci[f]) {
                fibonacci_count++;
                break;
            }
        }
    }
    
    // Check for prime triplets
    for (size_t i = 0; i < count - 2; i++) {
        if (primes[i+2] - primes[i] <= 8) {
            triplet_count++;
        }
    }
    
    // Calculate weighted harmonic score
    score = (twin_count * 5.0 + 
             cousin_count * 3.0 + 
             sexy_count * 2.5 + 
             fibonacci_count * 4.0 + 
             triplet_count * 7.0) / count;
    
    return score;
}

// Define resonance network structure
typedef struct {
    uint32_t node_count;         // Number of nodes in network
    prime_node_t* nodes;         // Array of prime nodes
    uint32_t edge_count;         // Number of edges
    prime_edge_t* edges;         // Array of edges connecting nodes
    double network_stability;    // Overall network stability
    double resonance_magnitude;  // Calculated resonance magnitude
} resonance_network_t;

// Build prime resonance network
resonance_network_t* buildResonanceNetwork(uint64_t max_prime, 
                                        double connection_threshold) {
    // Allocate network structure
    resonance_network_t* network = (resonance_network_t*)malloc(
        sizeof(resonance_network_t));
    
    // Generate prime list
    uint32_t max_nodes = (uint32_t)(max_prime / (log(max_prime) - 1.1));
    network->nodes = (prime_node_t*)malloc(max_nodes * sizeof(prime_node_t));
    network->node_count = 0;
    
    // Fill node array with primes
    for (uint64_t n = 2; n <= max_prime; n++) {
        if (isPrime(n)) {
            // Create node for this prime
            network->nodes[network->node_count].value = n;
            network->nodes[network->node_count].connections = 0;
            network->nodes[network->node_count].resonance_strength = 
                calculatePrimeResonance(n);
            
            network->node_count++;
        }
    }
    
    // Allocate edges (maximum possible edges is n*(n-1)/2)
    uint32_t max_edges = network->node_count * (network->node_count - 1) / 2;
    network->edges = (prime_edge_t*)malloc(max_edges * sizeof(prime_edge_t));
    network->edge_count = 0;
    
    // Create edges between resonant primes
    for (uint32_t i = 0; i < network->node_count; i++) {
        for (uint32_t j = i + 1; j < network->node_count; j++) {
            // Calculate resonance between nodes
            double resonance = calculateNodeResonance(
                network->nodes[i], network->nodes[j]);
            
            // If resonance meets threshold, create edge
            if (resonance >= connection_threshold) {
                network->edges[network->edge_count].from = i;
                network->edges[network->edge_count].to = j;
                network->edges[network->edge_count].strength = resonance;
                
                network->edge_count++;
                network->nodes[i].connections++;
                network->nodes[j].connections++;
            }
        }
    }
    
    // Calculate network properties
    calculateNetworkProperties(network);
    
    return network;
}

// Define dimensional mapping structure
typedef struct {
    uint32_t source_dimension;     // Source dimension
    uint32_t target_dimension;     // Target dimension
    uint64_t* prime_anchors;       // Array of prime anchor points
    uint32_t anchor_count;         // Number of prime anchor points
    transformation_matrix_t matrix; // Transformation matrix
} dimensional_map_t;

// Create dimensional mapping using prime anchors
dimensional_map_t* createDimensionalMap(uint32_t source_dim, 
                                      uint32_t target_dim, 
                                      uint64_t max_prime) {
    // Allocate map structure
    dimensional_map_t* map = (dimensional_map_t*)malloc(
        sizeof(dimensional_map_t));
    
    map->source_dimension = source_dim;
    map->target_dimension = target_dim;
    
    // Determine optimal prime anchors for this mapping
    determinePrimeAnchors(map, max_prime);
    
    // Initialize transformation matrix
    initTransformationMatrix(&map->matrix, source_dim, target_dim);
    
    // Calculate matrix coefficients based on prime anchors
    calculateMatrixFromAnchors(map);
    
    return map;
}

// Map a point between dimensions
void mapPointBetweenDimensions(dimensional_map_t* map, 
                             double* source_point, 
                             double* target_point) {
    // Apply transformation matrix to source point
    applyTransformationMatrix(&map->matrix, source_point, target_point);
    
    // Apply prime resonance corrections
    for (uint32_t i = 0; i < map->anchor_count; i++) {
        // Calculate influence of this prime anchor
        double influence = calculatePrimeInfluence(
            map->prime_anchors[i], source_point, map->source_dimension);
        
        // Apply correction to each target dimension
        for (uint32_t d = 0; d < map->target_dimension; d++) {
            target_point[d] += influence * getPrimeCorrection(
                map->prime_anchors[i], d);
        }
    }
}

// Define prime anchor structure
typedef struct {
    uint64_t prime;               // Prime number value
    uint32_t dimension;           // Associated dimension
    double resonance_strength;    // Anchor resonance strength
    uint32_t stability_index;     // Anchor stability index
} prime_anchor_t;

// Find optimal prime anchors for a specific dimensional mapping
prime_anchor_t* findOptimalAnchors(uint32_t source_dim, 
                                 uint32_t target_dim, 
                                 uint32_t count) {
    // Allocate anchor array
    prime_anchor_t* anchors = (prime_anchor_t*)malloc(
        count * sizeof(prime_anchor_t));
    
    // Find special primes for this dimensional transformation
    uint64_t max_search = 10000;  // Search limit
    uint32_t found = 0;
    
    // For each potential prime
    for (uint64_t p = 2; p <= max_search && found < count; p++) {
        if (isPrime(p)) {
            // Calculate dimensional resonance for this prime
            double resonance = calculateDimensionalResonance(
                p, source_dim, target_dim);
            
            // Calculate stability index
            uint32_t stability = calculatePrimeStability(p);
            
            // If resonance is above threshold, add to anchors
            if (resonance > 0.7) {  // Resonance threshold
                anchors[found].prime = p;
                anchors[found].dimension = 
                    (resonance > 0.9) ? target_dim : source_dim;
                anchors[found].resonance_strength = resonance;
                anchors[found].stability_index = stability;
                
                found++;
            }
        }
    }
    
    // Sort anchors by resonance strength
    sortAnchorsByResonance(anchors, found);
    
    return anchors;
}

// Define transdimensional operation types
typedef enum {
    OP_DIMENSION_PROMOTE,     // Promote to higher dimension
    OP_DIMENSION_DEMOTE,      // Demote to lower dimension
    OP_DIMENSION_SHIFT,       // Lateral shift within dimension
    OP_DIMENSION_ROTATE,      // Rotate within dimension using prime axis
    OP_DIMENSION_MORPH        // Morph dimensional representation
} transdim_operation_t;

// Apply transdimensional operation
void applyTransdimensionalOp(void* data, size_t data_size, 
                          transdim_operation_t op_type, 
                          uint32_t source_dim, uint32_t target_dim) {
    // Create dimensional map for this operation
    dimensional_map_t* map = createDimensionalMap(source_dim, target_dim, 10000);
    
    // Apply operation based on type
    switch (op_type) {
        case OP_DIMENSION_PROMOTE:
            promoteDimension(data, data_size, source_dim, target_dim, map);
            break;
            
        case OP_DIMENSION_DEMOTE:
            demoteDimension(data, data_size, source_dim, target_dim, map);
            break;
            
        case OP_DIMENSION_SHIFT:
            shiftDimension(data, data_size, source_dim, map);
            break;
            
        case OP_DIMENSION_ROTATE:
            rotateDimension(data, data_size, source_dim, map);
            break;
            
        case OP_DIMENSION_MORPH:
            morphDimension(data, data_size, source_dim, target_dim, map);
            break;
    }
    
    // Free resources
    freeDimensionalMap(map);
}

// Initialize Harmonic Prime Resonance system
HarmonicPrime* harmonic_prime_init() {
    HarmonicPrime* hp = (HarmonicPrime*)malloc(sizeof(HarmonicPrime));
    
    // Initialize subsystems
    hp->color_system = initColorSystem();
    hp->resonance_system = initResonanceSystem();
    hp->dimensional_system = initDimensionalSystem();
    
    // Set default configuration
    hp->max_prime = 10000;
    hp->default_resolution = PRIME_RESOLUTION_MEDIUM;
    hp->default_chromatic_mode = COLOR_MODE_STANDARD;
    
    // Precompute prime table for efficiency
    hp->prime_table = buildPrimeTable(hp->max_prime);
    
    return hp;
}

// Build chromatic representation of number range
chromatic_map_t* harmonic_prime_buildChromaticMap(HarmonicPrime* hp, 
                                               uint64_t min, 
                                               uint64_t max) {
    // Validate range
    if (min >= max) {
        fprintf(stderr, "Error: Invalid range (min must be less than max)\n");
        return NULL;
    }
    
    // Allocate map structure
    chromatic_map_t* map = (chromatic_map_t*)malloc(sizeof(chromatic_map_t));
    
    // Set range
    map->min = min;
    map->max = max;
    map->count = max - min + 1;
    
    // Allocate color array
    map->colors = (number_color_t*)malloc(map->count * sizeof(number_color_t));
    
    // Determine color for each number
    for (uint64_t n = min; n <= max; n++) {
        map->colors[n - min] = determineNumberColor(n);
    }
    
    // Calculate map properties
    calculateChromaticProperties(map);
    
    return map;
}

// Find prime clusters in number range
prime_cluster_t* harmonic_prime_findClusters(HarmonicPrime* hp, 
                                          uint64_t min, 
                                          uint64_t max, 
                                          double min_density,
                                          uint32_t* cluster_count) {
    return findPrimeClusters(min, max, min_density, cluster_count);
}

// Create resonance network
resonance_network_t* harmonic_prime_createResonanceNetwork(HarmonicPrime* hp, 
                                                       uint64_t max_prime, 
                                                       double connection_threshold) {
    return buildResonanceNetwork(max_prime, connection_threshold);
}

// Create dimensional mapping
dimensional_map_t* harmonic_prime_createDimensionalMap(HarmonicPrime* hp, 
                                                    uint32_t source_dim, 
                                                    uint32_t target_dim) {
    return createDimensionalMap(source_dim, target_dim, hp->max_prime);
}

// Apply chromatic transformation
void harmonic_prime_applyTransformation(HarmonicPrime* hp, 
                                     uint64_t* numbers, 
                                     size_t count, 
                                     chromatic_transform_t transform_type) {
    applyToPrimeChromatic(numbers, count, transform_type);
}

// Set chromatic visualization mode
void harmonic_prime_setVisualizationMode(HarmonicPrime* hp, 
                                       chromatic_mode_t mode) {
    hp->default_chromatic_mode = mode;
    
    // Update color mapping functions based on mode
    switch (mode) {
        case COLOR_MODE_STANDARD:
            hp->color_func = determineStandardColor;
            break;
            
        case COLOR_MODE_RESONANCE:
            hp->color_func = determineResonanceColor;
            break;
            
        case COLOR_MODE_HARMONIC:
            hp->color_func = determineHarmonicColor;
            break;
            
        case COLOR_MODE_DIMENSIONAL:
            hp->color_func = determineDimensionalColor;
            break;
            
        case COLOR_MODE_CLUSTER:
            hp->color_func = determineClusterColor;
            break;
    }
}

// Optimize Harmonic Prime performance
void optimizeHarmonicPrimePerformance(HarmonicPrime* hp, 
                                    optimization_level_t level) {
    // Set optimization level
    hp->optimization_level = level;
    
    // Configure based on level
    switch (level) {
        case OPTIMIZATION_MINIMAL:
            hp->max_prime = 10000;
            hp->use_cache = false;
            hp->segment_size = 1000;
            hp->connection_threshold = 0.3;
            break;
            
        case OPTIMIZATION_BALANCED:
            hp->max_prime = 100000;
            hp->use_cache = true;
            hp->segment_size = 10000;
            hp->connection_threshold = 0.5;
            break;
            
        case OPTIMIZATION_MAXIMAL:
            hp->max_prime = 1000000;
            hp->use_cache = true;
            hp->segment_size = 100000;
            hp->connection_threshold = 0.7;
            break;
    }
    
    // Initialize or update prime cache
    if (hp->use_cache) {
        if (hp->prime_table) {
            freePrimeTable(hp->prime_table);
        }
        hp->prime_table = buildPrimeTable(hp->max_prime);
    }
    
    // Configure resonance system
    configureResonanceSystem(hp->resonance_system, 
                           hp->connection_threshold);
    
    // Configure dimensional system
    configureDimensionalSystem(hp->dimensional_system, 
                             hp->optimization_level);
}

// Integrate Harmonic Prime with GeoMath
void integrateWithGeoMath(HarmonicPrime* hp, GeoMath* gm) {
    // Connect Harmonic Prime's resonance system to GeoMath's transformations
    hp->geomath = gm;
    
    // Configure prime-based resonance nodes
    configurePrimeResonanceNodes(hp, gm);
    
    // Set up prime-based transformation anchors
    setupPrimeTransformationAnchors(hp, gm);
    
    // Map chromatic visualization to geometric structures
    mapChromaticToGeometric(hp, gm);
    
    // Initialize prime-based harmonic operations
    initPrimeHarmonicOperations(hp, gm);
}

// Integrate Harmonic Prime with 4D Mathematics
void integrateWith4DMath(HarmonicPrime* hp, FourDMath* math) {
    // Connect Harmonic Prime's dimensional system to 4D Math
    hp->math_library = math;
    
    // Set up prime-based dimensional anchors
    setupPrimeDimensionalAnchors(hp, math);
    
    // Configure transdimensional operations
    configureTransdimensionalOperations(hp, math);
    
    // Map resonance patterns to 4D structures
    mapResonanceTo4DStructures(hp, math);
    
    // Initialize prime-based 4D operations
    initPrime4DOperations(hp, math);
}

// Integrate Harmonic Prime with DragonHeart
void integrateWithDragonHeart(HarmonicPrime* hp, DragonHeart* heart) {
    // Connect Harmonic Prime's resonance patterns to DragonHeart
    heart->harmonic_prime = hp;
    
    // Set up prime-based processing modes
    setupPrimeProcessingModes(hp, heart);
    
    // Configure resonance-based timing
    configurePrimeResonanceTiming(hp, heart);
    
    // Map chromatic visualizations to wave patterns
    mapChromaticToWavePatterns(hp, heart);
    
    // Initialize prime-based wave operations
    initPrimeWaveOperations(hp, heart);
}

#include "harmonic_prime.h"

int main() {
    // Initialize Harmonic Prime Resonance
    HarmonicPrime* hp = harmonic_prime_init();
    
    printf("Initialized Harmonic Prime Resonance system\n");
    
    // Build chromatic map for numbers 1-100
    chromatic_map_t* map = harmonic_prime_buildChromaticMap(hp, 1, 100);
    
    printf("Built chromatic map for numbers 1-100\n");
    printf("Prime count: %d\n", map->prime_count);
    
    // Print prime numbers found
    printf("Primes in range: ");
    for (uint64_t i = 0; i < map->count; i++) {
        if (map->colors[i] == COLOR_RED) {
            printf("%lu ", i + map->min);
        }
    }
    printf("\n");
    
    // Find prime clusters
    uint32_t cluster_count = 0;
    prime_cluster_t* clusters = harmonic_prime_findClusters(
        hp, 1, 1000, 0.3, &cluster_count);
    
    printf("Found %d prime clusters in range 1-1000\n", cluster_count);
    
    // Print top 3 clusters by density
    printf("Top clusters by density:\n");
    for (uint32_t i = 0; i < 3 && i < cluster_count; i++) {
        printf("Cluster %d: Range %lu-%lu, Density %.2f, Primes %d\n",
               i + 1, clusters[i].start, clusters[i].end, 
               clusters[i].density, clusters[i].prime_count);
    }
    
    // Create resonance network
    resonance_network_t* network = harmonic_prime_createResonanceNetwork(
        hp, 100, 0.5);
    
    printf("Created resonance network with %d nodes and %d edges\n",
           network->node_count, network->edge_count);
    printf("Network stability: %.2f\n", network->network_stability);
    
    // Free resources
    harmonic_prime_freeResonanceNetwork(hp, network);
    harmonic_prime_freeClusters(hp, clusters);
    harmonic_prime_freeChromaticMap(hp, map);
    harmonic_prime_free(hp);
    
    return 0;
}

// Demonstrate chromatic transformations
void demonstrateChromaticTransformations() {
    // Initialize Harmonic Prime Resonance
    HarmonicPrime* hp = harmonic_prime_init();
    
    // Create number array
    const uint32_t NUM_COUNT = 20;
    uint64_t numbers[NUM_COUNT];
    
    // Initialize with consecutive numbers 1-20
    for (uint32_t i = 0; i < NUM_COUNT; i++) {
        numbers[i] = i + 1;
    }
    
    printf("Original numbers:\n");
    for (uint32_t i = 0; i < NUM_COUNT; i++) {
        printf("%lu ", numbers[i]);
    }
    printf("\n\n");
    
    // Apply prime shift transformation
    harmonic_prime_applyTransformation(hp, numbers, NUM_COUNT, 
                                     TRANSFORM_PRIME_SHIFT);
    
    printf("After prime shift transformation:\n");
    for (uint32_t i = 0; i < NUM_COUNT; i++) {
        printf("%lu ", numbers[i]);
    }
    printf("\n\n");
    
    // Reset numbers
    for (uint32_t i = 0; i < NUM_COUNT; i++) {
        numbers[i] = i + 1;
    }
    
    // Apply resonance amplify transformation
    harmonic_prime_applyTransformation(hp, numbers, NUM_COUNT, 
                                     TRANSFORM_RESONANCE_AMPLIFY);
    
    printf("After resonance amplify transformation:\n");
    for (uint32_t i = 0; i < NUM_COUNT; i++) {
        printf("%lu ", numbers[i]);
    }
    printf("\n\n");
    
    // Free resources
    harmonic_prime_free(hp);
}

// Demonstrate dimensional mapping
void demonstrateDimensionalMapping() {
    // Initialize Harmonic Prime Resonance
    HarmonicPrime* hp = harmonic_prime_init();
    
    // Create source points in 2D
    const uint32_t POINT_COUNT = 5;
    double source_points[POINT_COUNT][2] = {
        {1.0, 0.0},
        {0.0, 1.0},
        {-1.0, 0.0},
        {0.0, -1.0},
        {0.5, 0.5}
    };
    
    // Create target arrays for 3D points
    double target_points[POINT_COUNT][3];
    
    // Create dimensional map from 2D to 3D
    dimensional_map_t* map = harmonic_prime_createDimensionalMap(hp, 2, 3);
    
    printf("Created dimensional map from 2D to 3D\n");
    printf("Using %d prime anchors\n", map->anchor_count);
    
    // Map each point from 2D to 3D
    for (uint32_t i = 0; i < POINT_COUNT; i++) {
        // Map point
        mapPointBetweenDimensions(map, source_points[i], target_points[i]);
        
        // Print results
        printf("Point %d:\n", i + 1);
        printf("  2D: (%.2f, %.2f)\n", 
               source_points[i][0], source_points[i][1]);
        printf("  3D: (%.2f, %.2f, %.2f)\n", 
               target_points[i][0], target_points[i][1], target_points[i][2]);
    }
    
    // Free resources
    harmonic_prime_freeDimensionalMap(hp, map);
    harmonic_prime_free(hp);
}